Add PickClutter smoke_v5 benchmark GIF renders

Upload the full smoke_v5_eval_tuned_softerpref dense-occlusion GIF rerender bundle, manifest/index, renderer script, and top-level docs updates.

.gitattributes

@@ -36,3 +36,103 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/__pycache__/run_maniskill_pickclutter_smoke.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/__pycache__/run_maniskill_bridge_retrieval_smoke.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 reports/proxy_rank_only_live/active/reveal_benchmark.json filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172000.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172001.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172002.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172003.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172004.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172005.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172006.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172007.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172008.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172009.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172010.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172011.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172012.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172013.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172014.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172015.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172016.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172017.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172018.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172019.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172020.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172021.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172022.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172023.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172024.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172025.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172026.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172027.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172028.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172029.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172030.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172031.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172032.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172033.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172034.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172035.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172036.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172037.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172038.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172039.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172040.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172041.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172042.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172043.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172044.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172045.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172046.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172047.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172048.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/adapter_active_ft/seed_172049.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172000.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172001.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172002.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172003.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172004.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172005.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172006.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172007.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172008.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172009.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172010.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172011.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172012.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172013.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172014.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172015.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172016.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172017.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172018.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172019.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172020.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172021.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172022.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172023.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172024.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172025.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172026.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172027.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172028.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172029.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172030.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172031.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172032.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172033.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172034.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172035.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172036.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172037.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172038.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172039.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172040.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172041.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172042.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172043.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172044.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172045.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172046.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172047.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172048.gif filter=lfs diff=lfs merge=lfs -text
+reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/trunk_only_ft/seed_172049.gif filter=lfs diff=lfs merge=lfs -text

MODEL_AND_ARTIFACT_INDEX.md

@@ -16,6 +16,8 @@
 
 - `reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref/`
   - strongest current dense-occlusion result
+- `reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/`
+  - side-by-side visual rerender of the final dense-occlusion held-out benchmark
 - `reports/maniskill_bag_bridge_eval_less_bonus_seed17/`
 - `reports/maniskill_bag_bridge_eval_less_bonus_seed23/`
 - `reports/maniskill_bag_bridge_eval_less_bonus_2seed_manual_summary.json`
@@ -40,6 +42,10 @@
 - `docs/public_bridge_smoke_run_log_2026-04-01.md`
 - `docs/minimum_sign_of_life_maniskill_pickclutter_run_2026-04-01.md`
 
+## Main Current Render Code
+
+- `code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/render_maniskill_pickclutter_benchmark_gifs.py`
+
 ## Repo History
 
 - `history/VLAarchtests_previous_README.md`

PUBLIC_BENCHMARK_RESULTS.md

@@ -53,6 +53,10 @@ Benchmark:
   - `95% CI = [0.44, 0.72]`
   - `intervention_rate = 1.0`
   - `non_base_selection_rate = 1.0`
+- `reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/`
+  - full rerender of all `50` held-out seeds for `trunk_only_ft` and `adapter_active_ft`
+  - includes `index.html`, `INDEX.md`, and `manifest.json`
+  - rerender manifest reports `0` success mismatches against the saved benchmark json files
 
 ### Exact `smoke_v5` eval tuning carried to held-out
 

README.md

@@ -33,6 +33,7 @@ The main new addition in this repo is the public benchmark track work for the el
   - ManiSkill bridge cloth retrieval proxy as the folded-cloth retrieval proxy
 - the public benchmark package code and summaries
 - the train/eval logs, checkpoints, cached datasets, validation sweeps, and correction logs for those runs
+- full visual rerenders of the final `smoke_v5_eval_tuned_softerpref` dense-occlusion benchmark for both `trunk_only_ft` and `adapter_active_ft`
 - the same-machine environment snapshot for the public benchmark stack used on this RunPod
 
 ## Top-Level Contents
@@ -60,6 +61,24 @@ The main new addition in this repo is the public benchmark track work for the el
 - `MODEL_AND_ARTIFACT_INDEX.md`
   - practical map of the main artifact roots to start from
 
+## Benchmark GIF Renders
+
+The repo now also includes a full rendered replay of the final dense-occlusion benchmark:
+
+- `reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/`
+  - `50` held-out `trunk_only_ft` gifs
+  - `50` held-out `adapter_active_ft` gifs
+  - `index.html`, `INDEX.md`, and `manifest.json` for browsing and validation
+- renderer:
+  - `code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/render_maniskill_pickclutter_benchmark_gifs.py`
+
+Important caveats:
+
+- these gifs are rerendered from the saved `smoke_v5_eval_tuned_softerpref` checkpoints and exact held-out seeds, not a different benchmark run
+- the rerender kept the same `softer_pref` planner override used in the reported held-out result
+- the rerender manifest records `0` success mismatches versus the saved benchmark json files
+- only the dense-occlusion track has this full gif export right now
+
 ## Architecture State Carried Forward
 
 The core model family inherited from `VLAarchtests3` is still:
@@ -218,6 +237,21 @@ The big changes across `smoke_v2`, `smoke_v3`, `smoke_v4`, and `smoke_v5` were:
 
 The big occlusion win was not caused by changing the eval episodes.
 
+### Dense-Occlusion Render Artifacts
+
+The final dense-occlusion run also has a full visual export in:
+
+- `reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/`
+
+Those gifs show the robot interacting with the 3D scene and overlay the adaptor state per frame. For `adapter_active_ft`, the overlay includes:
+
+- adaptor on/off state
+- whether a non-base proposal was selected
+- candidate index
+- planner name
+- planner score/confidence
+- state signals such as visibility, access, gap, and damage
+
 ## Crucial Caveats
 
 ### Occlusion result was planner-tuned

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

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

reports/maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs/INDEX.md

@@ -0,0 +1,59 @@
+# PickClutter smoke_v5_eval_tuned_softerpref GIF index
+
+- exact checkpoints: `maniskill_pickclutter_smoke_v5` seed17
+- exact held-out seeds: `172000..172049`
+- exact planner override: `softer_pref`
+- overlays show selected mode and adaptor state on each frame
+
+| episode_seed | trunk_only_ft | success | adapter_active_ft | success |
+| --- | --- | --- | --- | --- |
+| 172000 | [gif](trunk_only_ft/seed_172000.gif) | False | [gif](adapter_active_ft/seed_172000.gif) | True |
+| 172001 | [gif](trunk_only_ft/seed_172001.gif) | False | [gif](adapter_active_ft/seed_172001.gif) | True |
+| 172002 | [gif](trunk_only_ft/seed_172002.gif) | True | [gif](adapter_active_ft/seed_172002.gif) | True |
+| 172003 | [gif](trunk_only_ft/seed_172003.gif) | False | [gif](adapter_active_ft/seed_172003.gif) | False |
+| 172004 | [gif](trunk_only_ft/seed_172004.gif) | False | [gif](adapter_active_ft/seed_172004.gif) | True |
+| 172005 | [gif](trunk_only_ft/seed_172005.gif) | False | [gif](adapter_active_ft/seed_172005.gif) | True |
+| 172006 | [gif](trunk_only_ft/seed_172006.gif) | False | [gif](adapter_active_ft/seed_172006.gif) | False |
+| 172007 | [gif](trunk_only_ft/seed_172007.gif) | False | [gif](adapter_active_ft/seed_172007.gif) | False |
+| 172008 | [gif](trunk_only_ft/seed_172008.gif) | False | [gif](adapter_active_ft/seed_172008.gif) | False |
+| 172009 | [gif](trunk_only_ft/seed_172009.gif) | False | [gif](adapter_active_ft/seed_172009.gif) | True |
+| 172010 | [gif](trunk_only_ft/seed_172010.gif) | False | [gif](adapter_active_ft/seed_172010.gif) | True |
+| 172011 | [gif](trunk_only_ft/seed_172011.gif) | False | [gif](adapter_active_ft/seed_172011.gif) | True |
+| 172012 | [gif](trunk_only_ft/seed_172012.gif) | False | [gif](adapter_active_ft/seed_172012.gif) | False |
+| 172013 | [gif](trunk_only_ft/seed_172013.gif) | False | [gif](adapter_active_ft/seed_172013.gif) | False |
+| 172014 | [gif](trunk_only_ft/seed_172014.gif) | False | [gif](adapter_active_ft/seed_172014.gif) | False |
+| 172015 | [gif](trunk_only_ft/seed_172015.gif) | False | [gif](adapter_active_ft/seed_172015.gif) | False |
+| 172016 | [gif](trunk_only_ft/seed_172016.gif) | True | [gif](adapter_active_ft/seed_172016.gif) | True |
+| 172017 | [gif](trunk_only_ft/seed_172017.gif) | False | [gif](adapter_active_ft/seed_172017.gif) | True |
+| 172018 | [gif](trunk_only_ft/seed_172018.gif) | False | [gif](adapter_active_ft/seed_172018.gif) | True |
+| 172019 | [gif](trunk_only_ft/seed_172019.gif) | False | [gif](adapter_active_ft/seed_172019.gif) | False |
+| 172020 | [gif](trunk_only_ft/seed_172020.gif) | False | [gif](adapter_active_ft/seed_172020.gif) | True |
+| 172021 | [gif](trunk_only_ft/seed_172021.gif) | False | [gif](adapter_active_ft/seed_172021.gif) | True |
+| 172022 | [gif](trunk_only_ft/seed_172022.gif) | False | [gif](adapter_active_ft/seed_172022.gif) | True |
+| 172023 | [gif](trunk_only_ft/seed_172023.gif) | False | [gif](adapter_active_ft/seed_172023.gif) | True |
+| 172024 | [gif](trunk_only_ft/seed_172024.gif) | False | [gif](adapter_active_ft/seed_172024.gif) | False |
+| 172025 | [gif](trunk_only_ft/seed_172025.gif) | False | [gif](adapter_active_ft/seed_172025.gif) | True |
+| 172026 | [gif](trunk_only_ft/seed_172026.gif) | False | [gif](adapter_active_ft/seed_172026.gif) | True |
+| 172027 | [gif](trunk_only_ft/seed_172027.gif) | False | [gif](adapter_active_ft/seed_172027.gif) | True |
+| 172028 | [gif](trunk_only_ft/seed_172028.gif) | False | [gif](adapter_active_ft/seed_172028.gif) | False |
+| 172029 | [gif](trunk_only_ft/seed_172029.gif) | False | [gif](adapter_active_ft/seed_172029.gif) | True |
+| 172030 | [gif](trunk_only_ft/seed_172030.gif) | False | [gif](adapter_active_ft/seed_172030.gif) | True |
+| 172031 | [gif](trunk_only_ft/seed_172031.gif) | False | [gif](adapter_active_ft/seed_172031.gif) | False |
+| 172032 | [gif](trunk_only_ft/seed_172032.gif) | False | [gif](adapter_active_ft/seed_172032.gif) | True |
+| 172033 | [gif](trunk_only_ft/seed_172033.gif) | False | [gif](adapter_active_ft/seed_172033.gif) | True |
+| 172034 | [gif](trunk_only_ft/seed_172034.gif) | False | [gif](adapter_active_ft/seed_172034.gif) | True |
+| 172035 | [gif](trunk_only_ft/seed_172035.gif) | False | [gif](adapter_active_ft/seed_172035.gif) | True |
+| 172036 | [gif](trunk_only_ft/seed_172036.gif) | False | [gif](adapter_active_ft/seed_172036.gif) | False |
+| 172037 | [gif](trunk_only_ft/seed_172037.gif) | False | [gif](adapter_active_ft/seed_172037.gif) | False |
+| 172038 | [gif](trunk_only_ft/seed_172038.gif) | False | [gif](adapter_active_ft/seed_172038.gif) | True |
+| 172039 | [gif](trunk_only_ft/seed_172039.gif) | False | [gif](adapter_active_ft/seed_172039.gif) | True |
+| 172040 | [gif](trunk_only_ft/seed_172040.gif) | False | [gif](adapter_active_ft/seed_172040.gif) | True |
+| 172041 | [gif](trunk_only_ft/seed_172041.gif) | False | [gif](adapter_active_ft/seed_172041.gif) | True |
+| 172042 | [gif](trunk_only_ft/seed_172042.gif) | False | [gif](adapter_active_ft/seed_172042.gif) | False |
+| 172043 | [gif](trunk_only_ft/seed_172043.gif) | False | [gif](adapter_active_ft/seed_172043.gif) | False |
+| 172044 | [gif](trunk_only_ft/seed_172044.gif) | False | [gif](adapter_active_ft/seed_172044.gif) | True |
+| 172045 | [gif](trunk_only_ft/seed_172045.gif) | False | [gif](adapter_active_ft/seed_172045.gif) | False |
+| 172046 | [gif](trunk_only_ft/seed_172046.gif) | False | [gif](adapter_active_ft/seed_172046.gif) | True |
+| 172047 | [gif](trunk_only_ft/seed_172047.gif) | False | [gif](adapter_active_ft/seed_172047.gif) | False |
+| 172048 | [gif](trunk_only_ft/seed_172048.gif) | False | [gif](adapter_active_ft/seed_172048.gif) | False |
+| 172049 | [gif](trunk_only_ft/seed_172049.gif) | False | [gif](adapter_active_ft/seed_172049.gif) | True |