Add files using upload-large-folder tool

code/VLAarchtests2_code/VLAarchtests/artifacts/reports/proposal_alignment_diagnostics_smoke/proposal_alignment_diagnostics.json

@@ -0,0 +1,358 @@
+{
+  "checkpoint": "/workspace/VLAarchtests/artifacts/outputs/r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_seed17/checkpoint_best.pt",
+  "dataset_path": "/workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage3_phase.pt",
+  "teacher_macro_names_by_task": {
+    "foliage": [
+      "teacher",
+      "pin_canopy",
+      "maintain_gap",
+      "premature_retrieve",
+      "reveal_with_release",
+      "wrong_side_reveal",
+      "foliage_immediate_reocclusion",
+      "over_disturbance"
+    ]
+  },
+  "overall": {
+    "samples": 8,
+    "teacher_oracle_top1_accuracy": 1.0,
+    "proposal_teacher_utility_spearman": 0.9880235200593538,
+    "slotwise_reconstruction_mse": [
+      0.030513444915413857,
+      0.12480158358812332,
+      0.12676900625228882,
+      0.23568345606327057,
+      0.1129273921251297,
+      0.18383629620075226,
+      0.11721545457839966,
+      0.24060414731502533
+    ],
+    "slotwise_best_match_mse": [
+      0.030513444915413857,
+      0.08985880762338638,
+      0.07267005741596222,
+      0.08659016340970993,
+      0.08734967559576035,
+      0.08924143761396408,
+      0.0867096558213234,
+      0.09597492218017578
+    ],
+    "diagonal_reconstruction_mse": 0.14654386043548584,
+    "best_match_reconstruction_mse": 0.0798635184764862,
+    "teacher_slot_coverage_rate": [
+      1.0,
+      0.25,
+      0.0,
+      0.0,
+      0.375,
+      0.0,
+      0.0,
+      0.0
+    ],
+    "proposal_slot_teacher_confusion": [
+      [
+        8,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        6,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        8,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        8,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        5,
+        0,
+        0,
+        0,
+        3,
+        0,
+        0,
+        0
+      ],
+      [
+        7,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        5,
+        0,
+        0,
+        0,
+        3,
+        0,
+        0,
+        0
+      ],
+      [
+        8,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ],
+    "proposal_slot_best_teacher_slot": [
+      {
+        "proposal_slot": 0,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 1.0,
+        "support": 8
+      },
+      {
+        "proposal_slot": 1,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 0.75,
+        "support": 8
+      },
+      {
+        "proposal_slot": 2,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 1.0,
+        "support": 8
+      },
+      {
+        "proposal_slot": 3,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 1.0,
+        "support": 8
+      },
+      {
+        "proposal_slot": 4,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 0.625,
+        "support": 8
+      },
+      {
+        "proposal_slot": 5,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 0.875,
+        "support": 8
+      },
+      {
+        "proposal_slot": 6,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 0.625,
+        "support": 8
+      },
+      {
+        "proposal_slot": 7,
+        "best_teacher_slot": 0,
+        "best_teacher_slot_rate": 1.0,
+        "support": 8
+      }
+    ],
+    "proposal_candidate_pairwise_l2": 2.573041468858719
+  },
+  "by_task": {
+    "foliage": {
+      "samples": 8,
+      "teacher_oracle_top1_accuracy": 1.0,
+      "proposal_teacher_utility_spearman": 0.9880235200593538,
+      "slotwise_reconstruction_mse": [
+        0.030513444915413857,
+        0.12480158358812332,
+        0.12676900625228882,
+        0.23568345606327057,
+        0.1129273921251297,
+        0.18383629620075226,
+        0.11721545457839966,
+        0.24060414731502533
+      ],
+      "slotwise_best_match_mse": [
+        0.030513444915413857,
+        0.08985880762338638,
+        0.07267005741596222,
+        0.08659016340970993,
+        0.08734967559576035,
+        0.08924143761396408,
+        0.0867096558213234,
+        0.09597492218017578
+      ],
+      "diagonal_reconstruction_mse": 0.14654386043548584,
+      "best_match_reconstruction_mse": 0.0798635184764862,
+      "teacher_slot_coverage_rate": [
+        1.0,
+        0.25,
+        0.0,
+        0.0,
+        0.375,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "proposal_slot_teacher_confusion": [
+        [
+          8,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          6,
+          2,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          8,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          8,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          5,
+          0,
+          0,
+          0,
+          3,
+          0,
+          0,
+          0
+        ],
+        [
+          7,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          5,
+          0,
+          0,
+          0,
+          3,
+          0,
+          0,
+          0
+        ],
+        [
+          8,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ],
+      "proposal_slot_best_teacher_slot": [
+        {
+          "proposal_slot": 0,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 1.0,
+          "support": 8
+        },
+        {
+          "proposal_slot": 1,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 0.75,
+          "support": 8
+        },
+        {
+          "proposal_slot": 2,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 1.0,
+          "support": 8
+        },
+        {
+          "proposal_slot": 3,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 1.0,
+          "support": 8
+        },
+        {
+          "proposal_slot": 4,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 0.625,
+          "support": 8
+        },
+        {
+          "proposal_slot": 5,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 0.875,
+          "support": 8
+        },
+        {
+          "proposal_slot": 6,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 0.625,
+          "support": 8
+        },
+        {
+          "proposal_slot": 7,
+          "best_teacher_slot": 0,
+          "best_teacher_slot_rate": 1.0,
+          "support": 8
+        }
+      ],
+      "proposal_candidate_pairwise_l2": 2.573041468858719
+    }
+  }
+}

code/VLAarchtests2_code/VLAarchtests/artifacts/reports/rvt_overlap_branch_20260330/status.md

@@ -0,0 +1,58 @@
+# RVT Overlap Branch Status
+
+## Code Changes
+
+- added RVT residual output adapter in `/workspace/VLAarchtests/code/reveal_vla_bimanual/models/rvt_backbone.py`
+- added RVT frozen-stage config in `/workspace/VLAarchtests/code/reveal_vla_bimanual/train/configs/rlbench_subset3_backbone_only_rvt_100demo_frozen_seed17.yaml`
+- added RVT upper-layer stage config in `/workspace/VLAarchtests/code/reveal_vla_bimanual/train/configs/rlbench_subset3_backbone_only_rvt_100demo_unfreeze_top2_seed17.yaml`
+- made RLBench init checkpoint loading skip incompatible shapes when `init_strict=false` in `/workspace/VLAarchtests/code/reveal_vla_bimanual/train/run_rlbench_experiment.py`
+- added offline RLBench pickle bootstrap in `/workspace/VLAarchtests/code/reveal_vla_bimanual/sim_rlbench/dataset.py`
+- added overlap task alias mapping in `/workspace/VLAarchtests/code/reveal_vla_bimanual/sim_rlbench/task_resolver.py`
+- added branch summary script in `/workspace/VLAarchtests/code/reveal_vla_bimanual/eval/summarize_rvt_overlap_branch.py`
+- added branch runner in `/workspace/VLAarchtests/code/reveal_vla_bimanual/scripts/run_rvt_overlap_branch.sh`
+
+## Verification
+
+- `python -m py_compile` passed for:
+  - `models/rvt_backbone.py`
+  - `train/run_rlbench_experiment.py`
+  - `sim_rlbench/dataset.py`
+  - `sim_rlbench/task_resolver.py`
+  - `eval/summarize_rvt_overlap_branch.py`
+- `bash -n /workspace/VLAarchtests/code/reveal_vla_bimanual/scripts/run_rvt_overlap_branch.sh` passed
+- `pytest -q` passed for:
+  - `/workspace/VLAarchtests/tests/test_rvt_backbone_forward.py`
+  - `/workspace/VLAarchtests/tests/test_rlbench_dataset_rgbd_geometry.py`
+  - `/workspace/VLAarchtests/tests/test_eval_toggle_paths_work.py`
+  - `/workspace/VLAarchtests/tests/test_rlbench_init_checkpoint.py`
+  - `/workspace/VLAarchtests/tests/test_rlbench_pickle_bootstrap.py`
+  - `/workspace/VLAarchtests/tests/test_rlbench_task_resolver_aliases.py`
+  - `/workspace/VLAarchtests/tests/test_summarize_rvt_overlap_branch.py`
+
+## Stage 1 Train
+
+- checkpoint: `/workspace/outputs/rlbench_rvt_branch/rlbench_subset3_backbone_only_rvt_100demo_frozen_seed17/checkpoint_best.pt`
+- train summary: `/workspace/outputs/rlbench_rvt_branch/rlbench_subset3_backbone_only_rvt_100demo_frozen_seed17/summary.json`
+- final train total: `0.043179353826920445`
+- final val total: `0.039591669984665984`
+- train seconds: `2261.2839448451996`
+
+## Stage 1 Overlap Eval
+
+- rollout summary: `/workspace/reports/rvt_overlap_branch_20260330/evals/rlbench_subset3_backbone_only_rvt_100demo_frozen_seed17_noplan_split/rollout_eval.json`
+- `bimanual_push_box`: mean_success=`0.0`, mean_return=`0.0`
+- `bimanual_lift_ball`: mean_success=`0.0`, mean_return=`0.0`
+- `bimanual_dual_push_buttons`: mean_success=`0.0`, mean_return=`0.0`
+- stage1 mean_success=`0.0`
+
+## Gate
+
+- local AnyBimanual overlap floor: `0.16`
+- public AnyBimanual overlap best: `0.6933333333333334`
+- stage1 clears local floor: `false`
+- stage2 run: `false`
+
+## Summary Artifact
+
+- `/workspace/VLAarchtests/artifacts/reports/rvt_overlap_branch_20260330/summary.json`
+- `/workspace/VLAarchtests/artifacts/reports/rvt_overlap_branch_20260330/summary.md`

code/VLAarchtests2_code/VLAarchtests/artifacts/reports/rvt_overlap_branch_20260330/summary.json

@@ -0,0 +1,42 @@
+{
+  "anybimanual_local_overlap_floor": {
+    "path": "/workspace/VLAarchtests/artifacts/reports/anybimanual_overlap_baseline_20260330/resume1000_summary/summary.json",
+    "step": 1000,
+    "mean_success": 0.16,
+    "per_task_success": {
+      "coordinated_push_box": 0.0,
+      "coordinated_lift_ball": 0.0,
+      "dual_push_buttons": 0.48
+    }
+  },
+  "anybimanual_public_best_overlap": {
+    "path": "/workspace/VLAarchtests/artifacts/reports/anybimanual_overlap_baseline_20260330/resume1000_summary/summary.json",
+    "step": 60000,
+    "mean_success": 0.6933333333333334,
+    "per_task_success": {
+      "coordinated_push_box": 0.8,
+      "coordinated_lift_ball": 0.32,
+      "dual_push_buttons": 0.96
+    }
+  },
+  "stage1_frozen": {
+    "path": "/workspace/reports/rvt_overlap_branch_20260330/evals/rlbench_subset3_backbone_only_rvt_100demo_frozen_seed17_noplan_split/rollout_eval.json",
+    "checkpoint": "/workspace/outputs/rlbench_rvt_branch/rlbench_subset3_backbone_only_rvt_100demo_frozen_seed17/checkpoint_best.pt",
+    "mean_success": 0.0,
+    "per_task_success": {
+      "bimanual_push_box": 0.0,
+      "bimanual_lift_ball": 0.0,
+      "bimanual_dual_push_buttons": 0.0
+    },
+    "per_task_return": {
+      "bimanual_push_box": 0.0,
+      "bimanual_lift_ball": 0.0,
+      "bimanual_dual_push_buttons": 0.0
+    }
+  },
+  "stage2_unfreeze_top2": null,
+  "gates": {
+    "stage1_clears_local_floor": false,
+    "stage2_clears_local_floor": false
+  }
+}

code/VLAarchtests2_code/VLAarchtests/artifacts/reports/selector_finetune_v7_iter8/bag_fixed_default/reveal_benchmark.md

@@ -0,0 +1,15 @@
+# Reveal Proxy Benchmark
+
+## selector_finetune_iter8
+- controller: model
+- checkpoint: /workspace/VLAarchtests/artifacts/outputs/r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_v7_selector_finetune_iter8_seed17/checkpoint_best.pt
+- episodes: 100.000
+- mean_success: 0.410
+- visibility_integral: 38.913
+- corridor_availability: 0.816
+- reocclusion_rate: 0.020
+- disturbance_cost: 0.515
+- premature_retrieve_rate: 0.109
+- reocclusion_after_reveal_rate: 0.780
+- planner_regret: 0.127
+- bag_success: 0.410

code/VLAarchtests2_code/VLAarchtests/artifacts/reports/selector_finetune_v7_iter8/cloth_fixed_default/reveal_benchmark.md

@@ -0,0 +1,15 @@
+# Reveal Proxy Benchmark
+
+## selector_finetune_iter8
+- controller: model
+- checkpoint: /workspace/VLAarchtests/artifacts/outputs/r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_v7_selector_finetune_iter8_seed17/checkpoint_best.pt
+- episodes: 100.000
+- mean_success: 0.590
+- visibility_integral: 37.920
+- corridor_availability: 0.928
+- reocclusion_rate: 0.000
+- disturbance_cost: 0.206
+- premature_retrieve_rate: 0.113
+- reocclusion_after_reveal_rate: 0.000
+- planner_regret: 0.167
+- cloth_success: 0.590

code/VLAarchtests2_code/VLAarchtests/artifacts/reports/selector_finetune_v7_iter8/foliage_fixed_default/reveal_benchmark.md

@@ -0,0 +1,15 @@
+# Reveal Proxy Benchmark
+
+## selector_finetune_iter8
+- controller: model
+- checkpoint: /workspace/VLAarchtests/artifacts/outputs/r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_v7_selector_finetune_iter8_seed17/checkpoint_best.pt
+- episodes: 100.000
+- mean_success: 0.400
+- visibility_integral: 44.134
+- corridor_availability: 0.847
+- reocclusion_rate: 0.034
+- disturbance_cost: 0.302
+- premature_retrieve_rate: 0.110
+- reocclusion_after_reveal_rate: 0.570
+- planner_regret: 0.093
+- foliage_success: 0.400

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+.DS_Store
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.venv/
+artifacts/
+outputs/
+logs/
+wandb/
+reports/

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

@@ -0,0 +1,84 @@
+# 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.
+
+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,67 @@
+# 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`
+
+All new configs and scripts default to `~/workspace` outputs and reports.

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

@@ -0,0 +1,24 @@
+# Upstream Pins
+
+Pinned on 2026-03-22 in `/workspace/third_party`.
+
+Mandatory benchmark stack:
+
+- `peract_bimanual`: `bb0232a6ba3fe116566e9568f0c7af980ed6703d`
+- `RLBench`: `8af748c51287989294e00c9c670e3330a0e35ed5`
+- `PyRep`: `b8bd1d7a3182adcd570d001649c0849047ebf197`
+- `YARR`: `6822ff78602c77878b27d4cfe759ce029c67bffb`
+
+Optional published baseline:
+
+- `AnyBimanual`: `76024e48b0e9489101459e85bc909c126ec581b4`
+
+Reveal-proxy stack candidate:
+
+- `IsaacLab`: `v2.3.1` was cloned for inspection, but it targets Python 3.11 and Isaac Sim 5.x.
+- For the frozen project scope of Python 3.10 on Ubuntu 22.04, env B should stay on an Isaac Sim 4.5-compatible Isaac Lab release instead of the latest branch.
+
+Notes:
+
+- `peract_bimanual` defaults to 6 cameras and older Python/Torch pins. This repo overrides camera selection and environment creation rather than running the upstream install scripts unchanged.
+- RLBench headless execution on this RunPod host will require an X server setup because the base image does not currently ship `X`, `xvfb`, or `nvidia-xconfig`.

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/docs/xorg.rtx6000.conf

@@ -0,0 +1,32 @@
+Section "ServerLayout"
+    Identifier     "Layout0"
+    Screen      0  "Screen0"
+EndSection
+
+Section "Monitor"
+    Identifier     "Monitor0"
+    VendorName     "Unknown"
+    ModelName      "Unknown"
+    Option         "DPMS"
+EndSection
+
+Section "Device"
+    Identifier     "Device0"
+    Driver         "nvidia"
+    VendorName     "NVIDIA Corporation"
+    BusID          "PCI:65:0:0"
+    Option         "AllowEmptyInitialConfiguration" "True"
+    Option         "ProbeAllGpus" "False"
+EndSection
+
+Section "Screen"
+    Identifier     "Screen0"
+    Device         "Device0"
+    Monitor        "Monitor0"
+    DefaultDepth   24
+    Option         "AllowEmptyInitialConfiguration" "True"
+    SubSection     "Display"
+        Depth      24
+        Virtual    1280 1024
+    EndSubSection
+EndSection

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/envs/reveal310.yaml

@@ -0,0 +1,38 @@
+name: reveal310
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+dependencies:
+  - python=3.10
+  - pip
+  - git
+  - cmake
+  - ninja
+  - make
+  - gxx_linux-64
+  - pkg-config
+  - numpy=1.26.*
+  - pandas=2.2.*
+  - scipy=1.13.*
+  - matplotlib=3.8.*
+  - pyyaml=6.*
+  - imageio
+  - trimesh
+  - networkx
+  - psutil
+  - tqdm
+  - pytorch=2.3.1
+  - torchvision=0.18.1
+  - torchaudio=2.3.1
+  - pytorch-cuda=12.1
+  - pip:
+      - accelerate==0.31.0
+      - einops==0.8.0
+      - hydra-core==1.3.2
+      - omegaconf==2.3.0
+      - safetensors==0.4.3
+      - tensorboard==2.16.2
+      - timm==1.0.7
+      - transformers==4.41.2
+      - wandb==0.18.0

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/envs/rlbench310.yaml

@@ -0,0 +1,50 @@
+name: rlbench310
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+dependencies:
+  - python=3.10
+  - pip
+  - git
+  - cmake
+  - cffi
+  - ninja
+  - make
+  - gxx_linux-64
+  - pkg-config
+  - numpy=1.26.*
+  - pandas=2.2.*
+  - scipy=1.13.*
+  - matplotlib=3.8.*
+  - pyyaml=6.*
+  - h5py
+  - imageio
+  - pillow
+  - psutil
+  - tqdm
+  - trimesh
+  - pytorch=2.3.1
+  - torchvision=0.18.1
+  - torchaudio=2.3.1
+  - pytorch-cuda=12.1
+  - pip:
+      - accelerate==0.31.0
+      - absl-py==2.1.0
+      - clip @ git+https://github.com/openai/CLIP.git
+      - einops==0.8.0
+      - ftfy==6.2.0
+      - gym==0.26.2
+      - hydra-core==1.3.2
+      - natsort==8.4.0
+      - omegaconf==2.3.0
+      - perceiver-pytorch==0.8.8
+      - pyrender==0.1.45
+      - pytorch-lamb==1.0.0
+      - regex==2024.5.15
+      - rich==13.9.4
+      - rich-click==1.8.9
+      - safetensors==0.4.3
+      - tensorboard==2.16.2
+      - transformers==4.41.2
+      - wandb==0.18.0

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

@@ -0,0 +1,3 @@
+from eval.metrics import BenchmarkMetrics
+
+__all__ = ["BenchmarkMetrics"]

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

@@ -0,0 +1,7 @@
+MANDATORY_ABLATIONS: tuple[str, ...] = (
+    "no_planner",
+    "no_spatial_memory",
+    "no_task_head",
+    "no_geometry",
+    "no_camera_pose",
+)

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

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+def _load_summary(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    task_scores = {
+        task_name: float(task_payload.get("mean_success", 0.0))
+        for task_name, task_payload in payload.get("tasks", {}).items()
+    }
+    task_returns = {
+        task_name: float(task_payload.get("mean_return", 0.0))
+        for task_name, task_payload in payload.get("tasks", {}).items()
+    }
+    task_path_recoveries = {
+        task_name: float(sum(task_payload.get("path_recoveries", [])) / max(1, len(task_payload.get("path_recoveries", []))))
+        for task_name, task_payload in payload.get("tasks", {}).items()
+    }
+    task_noop_fallbacks = {
+        task_name: float(sum(task_payload.get("noop_fallbacks", [])) / max(1, len(task_payload.get("noop_fallbacks", []))))
+        for task_name, task_payload in payload.get("tasks", {}).items()
+    }
+    return {
+        "path": str(path),
+        "checkpoint": payload.get("checkpoint"),
+        "mean_success": float(payload.get("mean_success", 0.0)),
+        "mean_return": float(sum(task_returns.values()) / max(1, len(task_returns))),
+        "mean_path_recoveries": float(sum(task_path_recoveries.values()) / max(1, len(task_path_recoveries))),
+        "mean_noop_fallbacks": float(sum(task_noop_fallbacks.values()) / max(1, len(task_noop_fallbacks))),
+        "plan_requested": bool(payload.get("plan_requested", False)),
+        "plan_applied": bool(payload.get("plan_applied", False)),
+        "no_planner": bool(payload.get("no_planner", False)),
+        "no_geometry": bool(payload.get("no_geometry", False)),
+        "disable_task_conditioning": bool(payload.get("disable_task_conditioning", False)),
+        "compact_world_model": bool(payload.get("compact_world_model", False)),
+        "task_scores": task_scores,
+        "task_returns": task_returns,
+        "task_path_recoveries": task_path_recoveries,
+        "task_noop_fallbacks": task_noop_fallbacks,
+        "error_tasks": list(payload.get("error_tasks", [])),
+    }
+
+
+def _pairwise_delta(reference: dict[str, Any], candidate: dict[str, Any]) -> dict[str, Any]:
+    shared_tasks = sorted(set(reference["task_scores"]) & set(candidate["task_scores"]))
+    if not shared_tasks:
+        return {
+            "shared_task_count": 0,
+            "mean_success_delta": 0.0,
+            "mean_return_delta": 0.0,
+            "mean_path_recoveries_delta": 0.0,
+            "mean_noop_fallbacks_delta": 0.0,
+            "per_task_delta": {},
+        }
+    per_task_delta = {
+        task_name: float(candidate["task_scores"][task_name] - reference["task_scores"][task_name])
+        for task_name in shared_tasks
+    }
+    return {
+        "shared_task_count": len(shared_tasks),
+        "mean_success_delta": float(candidate["mean_success"] - reference["mean_success"]),
+        "mean_return_delta": float(candidate["mean_return"] - reference["mean_return"]),
+        "mean_path_recoveries_delta": float(candidate["mean_path_recoveries"] - reference["mean_path_recoveries"]),
+        "mean_noop_fallbacks_delta": float(candidate["mean_noop_fallbacks"] - reference["mean_noop_fallbacks"]),
+        "per_task_delta": per_task_delta,
+    }
+
+
+def _markdown_lines(reference_label: str, comparison: dict[str, Any]) -> list[str]:
+    lines = [
+        "# RLBench Sweep Comparison",
+        "",
+        f"- Reference: `{reference_label}`",
+        "",
+        "## Runs",
+        "",
+    ]
+    for label, payload in comparison["runs"].items():
+        lines.append(
+            f"- `{label}`: mean_success={payload['mean_success']:.3f}, "
+            f"mean_return={payload['mean_return']:.3f}, "
+            f"mean_path_recoveries={payload['mean_path_recoveries']:.3f}, "
+            f"mean_noop_fallbacks={payload['mean_noop_fallbacks']:.3f}, "
+            f"plan_applied={payload['plan_applied']}, "
+            f"errors={len(payload['error_tasks'])}, "
+            f"path=`{payload['path']}`"
+        )
+    lines.extend(["", "## Pairwise Deltas", ""])
+    for label, payload in comparison["pairwise_against_reference"].items():
+        lines.append(
+            f"- `{label}`: mean_success_delta={payload['mean_success_delta']:.3f}, "
+            f"mean_return_delta={payload['mean_return_delta']:.3f}, "
+            f"mean_path_recoveries_delta={payload['mean_path_recoveries_delta']:.3f}, "
+            f"mean_noop_fallbacks_delta={payload['mean_noop_fallbacks_delta']:.3f}, "
+            f"shared_tasks={payload['shared_task_count']}"
+        )
+    return lines
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run", action="append", required=True, help="label=/abs/path/to/rollout_eval.json")
+    parser.add_argument("--reference-label", required=True)
+    parser.add_argument("--output-dir", required=True)
+    args = parser.parse_args()
+
+    runs: dict[str, dict[str, Any]] = {}
+    for item in args.run:
+        label, raw_path = item.split("=", 1)
+        runs[label] = _load_summary(Path(raw_path).resolve())
+
+    if args.reference_label not in runs:
+        raise ValueError(f"Missing reference label {args.reference_label!r} in provided runs.")
+
+    reference = runs[args.reference_label]
+    comparison = {
+        "reference_label": args.reference_label,
+        "runs": runs,
+        "pairwise_against_reference": {
+            label: _pairwise_delta(reference, payload)
+            for label, payload in runs.items()
+            if label != args.reference_label
+        },
+    }
+
+    output_dir = Path(args.output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "rlbench_comparison.json").write_text(
+        json.dumps(comparison, indent=2),
+        encoding="utf-8",
+    )
+    (output_dir / "rlbench_comparison.md").write_text(
+        "\n".join(_markdown_lines(args.reference_label, comparison)) + "\n",
+        encoding="utf-8",
+    )
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from eval.metrics import summarize_episode_records
+
+
+def _load_benchmark_payload(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _infer_label(payload: dict[str, Any]) -> str:
+    labels = [key for key in payload.keys() if key != "benchmark_config"]
+    if len(labels) != 1:
+        raise ValueError(f"Expected exactly one model label in benchmark JSON, found {labels}.")
+    return labels[0]
+
+
+def _load_records(path: Path, label: str | None) -> tuple[str, list[dict[str, Any]]]:
+    payload = _load_benchmark_payload(path)
+    resolved_label = label or _infer_label(payload)
+    if resolved_label not in payload:
+        raise KeyError(f"Missing label {resolved_label!r} in benchmark JSON {path}.")
+    return resolved_label, list(payload[resolved_label].get("episode_records", []))
+
+
+def _mean_metrics(summary: dict[str, Any]) -> dict[str, float]:
+    return {
+        "visibility_integral": float(summary.get("visibility_integral", 0.0)),
+        "corridor_availability": float(summary.get("corridor_availability", 0.0)),
+        "reocclusion_rate": float(summary.get("reocclusion_rate", 0.0)),
+        "disturbance_cost": float(summary.get("disturbance_cost", 0.0)),
+        "premature_retrieve_rate": float(summary.get("premature_retrieve_rate", 0.0)),
+        "reocclusion_after_reveal_rate": float(summary.get("reocclusion_after_reveal_rate", 0.0)),
+        "planner_regret": float(summary.get("planner_regret", 0.0)),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", action="append", required=True, help="task_name=/abs/path/to/reveal_benchmark.json")
+    parser.add_argument("--label", action="append", default=[], help="task_name=model_label within the benchmark JSON")
+    parser.add_argument("--output-dir", required=True)
+    args = parser.parse_args()
+
+    labels_by_task: dict[str, str] = {}
+    for item in args.label:
+        task_name, label = item.split("=", maxsplit=1)
+        labels_by_task[task_name] = label
+
+    routing_policy: dict[str, str] = {}
+    sources: dict[str, str] = {}
+    combined_records: list[dict[str, Any]] = []
+
+    for item in args.source:
+        task_name, raw_path = item.split("=", maxsplit=1)
+        path = Path(raw_path).resolve()
+        label, records = _load_records(path, labels_by_task.get(task_name))
+        task_records = [record for record in records if str(record.get("task_name")) == task_name]
+        routing_policy[task_name] = label
+        sources[task_name] = str(path)
+        combined_records.extend(task_records)
+
+    summary = summarize_episode_records(combined_records)
+    per_task_success = summary.get("per_task_success", {})
+    payload = {
+        "controller": "task_routed_checkpoint_selection",
+        "routing_policy": routing_policy,
+        "per_task_success": per_task_success,
+        "mean_success": float(sum(per_task_success.values()) / max(1, len(per_task_success))),
+        "mean_metrics": _mean_metrics(summary),
+        "sources": sources,
+    }
+
+    output_dir = Path(args.output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "summary.json").write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    lines = [
+        "# Task-Routed Proxy Controller",
+        "",
+        "- routing rule: "
+        + ", ".join(f"`{task} -> {label}`" for task, label in routing_policy.items()),
+        f"- mean success: `{payload['mean_success']:.4f}`",
+        "",
+        "## Per-Task Success",
+        "",
+    ]
+    for task_name, score in per_task_success.items():
+        lines.append(f"- {task_name}: `{score:.2f}`")
+    lines.extend(["", "## Sources", ""])
+    for task_name, source in sources.items():
+        lines.append(f"- {task_name}: `{source}`")
+    (output_dir / "summary.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+
+def build_eval_protocol(
+    *,
+    eval_mode: str,
+    task_subset: Sequence[str],
+    seed: int = 17,
+    episodes: int = 25,
+    episode_length: int = 120,
+    resolution: int = 256,
+    cameras: Sequence[str] = ("front", "left_wrist", "right_wrist"),
+) -> dict[str, object]:
+    return {
+        "eval_mode": str(eval_mode),
+        "task_subset": tuple(str(task) for task in task_subset),
+        "seed": int(seed),
+        "episodes": int(episodes),
+        "episode_length": int(episode_length),
+        "resolution": int(resolution),
+        "cameras": tuple(str(camera) for camera in cameras),
+        "observation_stack": "rgbd_3cam",
+        "action_horizon": 8,
+        "action_space": "bimanual_delta_pose",
+    }
+
+
+def protocol_identity_signature(protocol: dict[str, object]) -> tuple[object, ...]:
+    return (
+        protocol["task_subset"],
+        protocol["seed"],
+        protocol["episodes"],
+        protocol["episode_length"],
+        protocol["resolution"],
+        protocol["cameras"],
+        protocol["observation_stack"],
+        protocol["action_horizon"],
+        protocol["action_space"],
+    )

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

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from models.action_decoder import infer_task_name_from_text
+
+
+def _infer_task_families(tasks: list[str], task_name: str) -> list[str]:
+    families = [infer_task_name_from_text(task_name)]
+    families.extend(infer_task_name_from_text(task) for task in tasks)
+    return sorted(set(families))
+
+
+def _parse_episode_scores(stdout: str) -> list[float]:
+    scores: list[float] = []
+    pattern = re.compile(r"Episode\s+\d+\s+\|\s+Score:\s*([0-9]+(?:\.[0-9]+)?)")
+    for match in pattern.finditer(stdout):
+        scores.append(float(match.group(1)))
+    return scores
+
+
+def _parse_final_score(stdout: str) -> float | None:
+    match = re.search(r"Final Score:\s*([0-9]+(?:\.[0-9]+)?)", stdout)
+    if match is None:
+        return None
+    return float(match.group(1))
+
+
+def _parse_eval_data_score(eval_csv_path: Path) -> float | None:
+    if not eval_csv_path.exists():
+        return None
+    with eval_csv_path.open("r", encoding="utf-8") as handle:
+        reader = csv.DictReader(handle)
+        last_row: dict[str, str] | None = None
+        for row in reader:
+            last_row = row
+    if last_row is None:
+        return None
+    value = last_row.get("eval_envs/return")
+    if value is None or value == "":
+        return None
+    return float(value)
+
+
+def _bootstrap_eval_seed_dir(
+    *,
+    framework_logdir: Path,
+    task_name: str,
+    method: str,
+) -> None:
+    seed_dir = framework_logdir / task_name / method / "seed0"
+    if (seed_dir / "config.yaml").exists():
+        return
+    release_seed_dir = Path("/workspace/baselines/AnyBimanual_release_eval_live") / task_name / method / "seed0"
+    if not (release_seed_dir / "config.yaml").exists():
+        return
+    seed_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(release_seed_dir / "config.yaml", seed_dir / "config.yaml")
+    release_weights_dir = release_seed_dir / "weights"
+    if release_weights_dir.exists() and not (seed_dir / "weights").exists():
+        os.symlink(release_weights_dir, seed_dir / "weights", target_is_directory=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task-name", required=True, help="Existing AnyBimanual logdir task name, e.g. perlf_release_dual_push_buttons_smoke1")
+    parser.add_argument("--tasks", nargs="+", required=True, help="RLBench task module names, e.g. dual_push_buttons")
+    parser.add_argument("--adapter-mode", choices=("trunk_only", "adapter_noop", "adapter_active"), default="trunk_only")
+    parser.add_argument("--episodes", type=int, default=1)
+    parser.add_argument("--eval-type", default="60000")
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--framework-logdir", default=None)
+    parser.add_argument("--demo-path", default="/workspace/baselines/AnyBimanual_subset3_demo_root")
+    parser.add_argument("--method", default="PERACT_BC")
+    parser.add_argument("--gpu", type=int, default=0)
+    args = parser.parse_args()
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    framework_logdir = Path(args.framework_logdir) if args.framework_logdir else (output_dir / "anybimanual_logdir")
+    framework_logdir.mkdir(parents=True, exist_ok=True)
+    _bootstrap_eval_seed_dir(
+        framework_logdir=framework_logdir,
+        task_name=args.task_name,
+        method=args.method,
+    )
+
+    task_families = _infer_task_families(list(args.tasks), args.task_name)
+    passthrough_only = all(family == "generic" for family in task_families)
+    if args.adapter_mode == "adapter_active" and not passthrough_only:
+        raise NotImplementedError(
+            "The AnyBimanual anchor bridge only supports generic-task pass-through active mode for now. "
+            f"Resolved task families: {task_families}"
+        )
+
+    command = [
+        sys.executable,
+        "/workspace/third_party/AnyBimanual/eval.py",
+        f"method={args.method}",
+        f"framework.logdir={framework_logdir}",
+        "framework.start_seed=0",
+        f"framework.eval_type={args.eval_type}",
+        f"framework.eval_episodes={args.episodes}",
+        "framework.eval_envs=1",
+        f"framework.gpu={args.gpu}",
+        f"rlbench.task_name={args.task_name}",
+        f"rlbench.tasks=[{','.join(args.tasks)}]",
+        f"rlbench.demo_path={args.demo_path}",
+        "rlbench.headless=True",
+        "rlbench.gripper_mode=BimanualDiscrete",
+        "rlbench.arm_action_mode=BimanualEndEffectorPoseViaPlanning",
+        "rlbench.action_mode=BimanualMoveArmThenGripper",
+    ]
+    env = os.environ.copy()
+    env.setdefault("DISPLAY", ":99")
+    env.setdefault("XDG_RUNTIME_DIR", "/workspace/runtime")
+    env.setdefault("COPPELIASIM_ROOT", "/workspace/assets/coppeliasim_v4_1_0")
+    env.setdefault("QT_QPA_PLATFORM_PLUGIN_PATH", env["COPPELIASIM_ROOT"])
+    env["LD_LIBRARY_PATH"] = f"{env['COPPELIASIM_ROOT']}:{env.get('LD_LIBRARY_PATH', '')}".rstrip(":")
+    pythonpath_items = [
+        "/workspace/third_party/RLBench",
+        "/workspace/third_party/YARR",
+        "/workspace/third_party/AnyBimanual",
+        "/workspace/reveal_vla_bimanual",
+    ]
+    existing_pythonpath = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = ":".join(pythonpath_items + ([existing_pythonpath] if existing_pythonpath else []))
+
+    stdout_path = output_dir / "stdout.txt"
+    stderr_path = output_dir / "stderr.txt"
+    with stdout_path.open("w", encoding="utf-8") as stdout_handle, stderr_path.open("w", encoding="utf-8") as stderr_handle:
+        completed = subprocess.run(
+            command,
+            env=env,
+            text=True,
+            stdout=stdout_handle,
+            stderr=stderr_handle,
+            close_fds=True,
+            check=False,
+        )
+    stdout = stdout_path.read_text(encoding="utf-8")
+    stderr = stderr_path.read_text(encoding="utf-8")
+    scores = _parse_episode_scores(stdout)
+    eval_csv_path = framework_logdir / args.task_name / args.method / "seed0" / "eval_data.csv"
+    final_score = _parse_eval_data_score(eval_csv_path)
+    if final_score is None:
+        final_score = _parse_final_score(stdout)
+    payload = {
+        "adapter_mode": args.adapter_mode,
+        "task_name": args.task_name,
+        "tasks": list(args.tasks),
+        "task_families": task_families,
+        "passthrough_only": passthrough_only,
+        "passthrough_reason": "generic_task_family" if passthrough_only else "unsupported_active_family",
+        "episodes_requested": int(args.episodes),
+        "episode_scores": scores,
+        "mean_score": final_score if final_score is not None else ((sum(scores) / float(len(scores))) if scores else 0.0),
+        "final_score": final_score,
+        "subprocess_returncode": int(completed.returncode),
+        "eval_csv_path": str(eval_csv_path),
+        "command": command,
+    }
+    (output_dir / "command.txt").write_text(" ".join(command) + "\n", encoding="utf-8")
+    (output_dir / "summary.json").write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(payload, indent=2))
+    if completed.returncode != 0:
+        raise SystemExit(completed.returncode)
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reveal-vla-bimanual"
+version = "0.1.0"
+description = "Language-conditioned bimanual reveal-and-retrieve policy prototype"
+readme = "README.md"
+requires-python = ">=3.10,<3.11"
+dependencies = [
+  "accelerate>=0.31.0",
+  "einops>=0.7.0",
+  "hydra-core>=1.3.2",
+  "matplotlib>=3.8.0",
+  "numpy>=1.26,<2.0",
+  "omegaconf>=2.3.0",
+  "pandas>=2.2.0",
+  "pyyaml>=6.0.1",
+  "safetensors>=0.4.3",
+  "tensorboard>=2.16.2",
+  "timm>=1.0.7",
+  "torch>=2.3.0",
+  "torchvision>=0.18.0",
+  "transformers>=4.41.0",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["sim_rlbench*", "sim_reveal*", "models*", "train*", "eval*", "pytorch3d*"]

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/__init__.py

@@ -0,0 +1,15 @@
+from sim_reveal.base import RevealProxyConfig, RevealState, SupportMode
+from sim_reveal.procedural_envs import ProceduralRevealEnv, available_proxy_names, make_proxy_env
+from sim_reveal.proxy_specs import BAG_PROXY, CLOTH_PROXY, FOLIAGE_PROXY
+
+__all__ = [
+    "BAG_PROXY",
+    "CLOTH_PROXY",
+    "FOLIAGE_PROXY",
+    "ProceduralRevealEnv",
+    "RevealProxyConfig",
+    "RevealState",
+    "SupportMode",
+    "available_proxy_names",
+    "make_proxy_env",
+]

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/base.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+
+import numpy as np
+
+
+class SupportMode(IntEnum):
+    HOLD = 0
+    TRANSFER = 1
+    PASSIVE = 2
+
+
+@dataclass
+class RevealState:
+    support_mode_logits: np.ndarray
+    corridor_logits: np.ndarray
+    persistence_horizon: np.ndarray
+    disturbance_cost: np.ndarray
+    belief_map: np.ndarray | None = None
+
+
+@dataclass
+class RevealProxyConfig:
+    name: str
+    num_templates: int = 32
+    rollout_horizon: int = 5
+    max_steps: int = 80
+    disturbance_key: str = "disturbance_cost"
+    success_key: str = "retrieval_success"
+    metadata: dict[str, str] = field(default_factory=dict)

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/build_task_specialized_episode_specs.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from sim_reveal.proxy_specs import TASK_ID_BY_NAME, TASK_NAME_BY_PROXY_NAME
+
+
+def _proxy_name_for_task(task_name: str) -> str:
+    for proxy_name, mapped_task_name in TASK_NAME_BY_PROXY_NAME.items():
+        if mapped_task_name == task_name:
+            return proxy_name
+    raise KeyError(f"Unknown task name: {task_name}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task-name", required=True)
+    parser.add_argument("--base-seed", type=int, default=0)
+    parser.add_argument(
+        "--block",
+        action="append",
+        required=True,
+        help="stress_slice,difficulty_bin,count",
+    )
+    parser.add_argument("--output-path", required=True)
+    args = parser.parse_args()
+
+    task_name = str(args.task_name)
+    if task_name not in TASK_ID_BY_NAME:
+        raise KeyError(f"Unknown task name: {task_name}")
+    proxy_name = _proxy_name_for_task(task_name)
+    task_id = TASK_ID_BY_NAME[task_name]
+
+    specs: list[dict[str, object]] = []
+    episode_index = 0
+    for block_index, raw_block in enumerate(args.block):
+        stress_slice, difficulty_bin, raw_count = [part.strip() for part in raw_block.split(",")]
+        count = int(raw_count)
+        for sample_index in range(count):
+            specs.append(
+                {
+                    "proxy_name": proxy_name,
+                    "task_name": task_name,
+                    "task_id": int(task_id),
+                    "stress_slice": stress_slice,
+                    "difficulty_bin": difficulty_bin,
+                    "episode_id": episode_index,
+                    "episode_index": episode_index,
+                    "seed": int(args.base_seed) + block_index * 10_000 + sample_index,
+                }
+            )
+            episode_index += 1
+
+    output_path = Path(args.output_path).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(specs, indent=2), encoding="utf-8")
+    print(
+        json.dumps(
+            {
+                "output_path": str(output_path),
+                "task_name": task_name,
+                "episodes": len(specs),
+                "blocks": args.block,
+            },
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/dataset.py

@@ -0,0 +1,634 @@
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+from typing import Any, Callable, Sequence
+
+import torch
+from torch import Tensor
+from torch.utils.data import Dataset
+
+import numpy as np
+
+from sim_reveal.procedural_envs import available_proxy_names, default_camera_matrices, make_proxy_env, render_views_from_state
+from sim_reveal.proxy_specs import task_id_from_task_name, task_name_from_proxy_name
+
+NOLEAK_PROXY_DATASET_VERSION = "reveal_proxy_v5_noleak_actionhist"
+RGBD_PROXY_DATASET_VERSION = "reveal_proxy_v6_rgbd_elastic_state"
+LEGACY_PRIVILEGED_RENDER_KEYS = frozenset(
+    {
+        "target_template",
+        "support_mode",
+        "visibility",
+        "actor_template",
+        "actor_progress",
+        "corridor_current",
+    }
+)
+
+
+def dataset_uses_rgbd(dataset_version: Any) -> bool:
+    version = str(dataset_version or "")
+    return version.startswith(RGBD_PROXY_DATASET_VERSION)
+
+
+def _assert_noleak_sample(sample: dict[str, Any]) -> None:
+    render_state = sample.get("render_state", {})
+    leaked_keys = sorted(LEGACY_PRIVILEGED_RENDER_KEYS.intersection(render_state))
+    if leaked_keys:
+        joined = ", ".join(leaked_keys)
+        raise ValueError(
+            "Legacy leaked proxy sample detected. Rebuild the dataset with the current "
+            f"sim_reveal/procedural_envs.py. Privileged render keys found: {joined}"
+        )
+
+
+def collect_teacher_dataset(
+    proxy_names: Sequence[str] | None = None,
+    episodes_per_proxy: int = 32,
+    resolution: int = 96,
+    seed: int = 0,
+    chunk_horizon: int = 8,
+    rollout_horizon: int = 5,
+    history_steps: int = 2,
+    planner_candidates: int = 4,
+    dataset_version: str = NOLEAK_PROXY_DATASET_VERSION,
+    episode_specs: Sequence[dict[str, Any]] | None = None,
+    proposal_target_builder: Callable[[Any, dict[str, Any], dict[str, Any]], dict[str, Any] | None] | None = None,
+) -> dict[str, Any]:
+    proxy_names = tuple(proxy_names or available_proxy_names())
+    samples: list[dict[str, Any]] = []
+    summary: dict[str, dict[str, float]] = {}
+    if episode_specs is None:
+        resolved_episode_specs = []
+        for proxy_offset, proxy_name in enumerate(proxy_names):
+            for episode_idx in range(episodes_per_proxy):
+                resolved_episode_specs.append(
+                    {
+                        "proxy_name": proxy_name,
+                        "episode_id": episode_idx,
+                        "seed": seed + proxy_offset * 10_000 + episode_idx,
+                        "stress_slice": "nominal",
+                        "difficulty_bin": "medium",
+                    }
+                )
+    else:
+        resolved_episode_specs = list(episode_specs)
+
+    specs_by_proxy: dict[str, list[dict[str, Any]]] = {proxy_name: [] for proxy_name in proxy_names}
+    for spec in resolved_episode_specs:
+        proxy_name = str(spec["proxy_name"])
+        specs_by_proxy.setdefault(proxy_name, []).append(spec)
+
+    for proxy_name in proxy_names:
+        proxy_specs = specs_by_proxy.get(proxy_name, [])
+        proxy_samples = 0
+        proxy_success = 0
+        for episode_idx, episode_spec in enumerate(proxy_specs):
+            episode_seed = int(episode_spec.get("seed", seed + episode_idx))
+            env = make_proxy_env(
+                proxy_name=proxy_name,
+                resolution=resolution,
+                seed=episode_seed,
+                rollout_horizon=rollout_horizon,
+                stress_slice=str(episode_spec.get("stress_slice", "nominal")),
+                difficulty_bin=str(episode_spec.get("difficulty_bin", "medium")),
+            )
+            observation, privileged_state = env.reset(seed=episode_seed)
+            history_buffer: list[dict[str, Any]] = []
+            while True:
+                action_chunk, rollout = env.teacher_chunk_and_rollout(
+                    chunk_horizon=chunk_horizon,
+                    rollout_horizon=rollout_horizon,
+                )
+                observation = env.get_observation(privileged_state)
+                candidate_action_chunks, candidate_outcomes = env.sample_candidate_action_chunks(
+                    teacher_chunk=action_chunk,
+                    num_candidates=planner_candidates,
+                    rollout_horizon=rollout_horizon,
+                )
+                padded_history_render_states = []
+                padded_history_proprio = []
+                padded_history_actions = []
+                padded_history_camera_intrinsics = []
+                padded_history_camera_extrinsics = []
+                padded_history_camera_valid_mask = []
+                history_count = min(history_steps, len(history_buffer))
+                pad_count = history_steps - history_count
+                if history_count > 0:
+                    recent_history = history_buffer[-history_count:]
+                else:
+                    recent_history = []
+                for _ in range(pad_count):
+                    padded_history_render_states.append(env.render_state(privileged_state))
+                    padded_history_proprio.append(np.zeros_like(observation["proprio"], dtype=np.float32))
+                    padded_history_actions.append(np.zeros((action_chunk.shape[-1],), dtype=np.float32))
+                    padded_history_camera_intrinsics.append(np.zeros((3, 3, 3), dtype=np.float32))
+                    padded_history_camera_extrinsics.append(np.zeros((3, 4, 4), dtype=np.float32))
+                    padded_history_camera_valid_mask.append(np.zeros((3,), dtype=np.float32))
+                for item in recent_history:
+                    padded_history_render_states.append(item["render_state"])
+                    padded_history_proprio.append(item["proprio"])
+                    padded_history_actions.append(item["action"])
+                    padded_history_camera_intrinsics.append(item["camera_intrinsics"])
+                    padded_history_camera_extrinsics.append(item["camera_extrinsics"])
+                    padded_history_camera_valid_mask.append(item["camera_valid_mask"])
+                task_name = str(observation.get("task_name", task_name_from_proxy_name(proxy_name)))
+                task_id = int(observation.get("task_id", task_id_from_task_name(task_name)))
+                sample = {
+                    "dataset_version": dataset_version,
+                    "proxy_name": proxy_name,
+                    "episode_id": int(episode_spec.get("episode_id", episode_idx)),
+                    "episode_seed": episode_seed,
+                    "task_name": task_name,
+                    "task_id": task_id,
+                    "stress_slice": str(observation.get("stress_slice", episode_spec.get("stress_slice", "nominal"))),
+                    "difficulty_bin": str(observation.get("difficulty_bin", episode_spec.get("difficulty_bin", "medium"))),
+                    "episode_metadata": dict(observation.get("episode_metadata", {})),
+                    "render_state": env.render_state(privileged_state),
+                    "camera_intrinsics": observation.get("camera_intrinsics", default_camera_matrices()[0]).astype("float32"),
+                    "camera_extrinsics": observation.get("camera_extrinsics", default_camera_matrices()[1]).astype("float32"),
+                    "camera_valid_mask": observation.get("camera_valid_mask", np.ones((3,), dtype=np.float32)).astype("float32"),
+                    "proprio": observation["proprio"].astype("float32"),
+                    "language_goal": observation["text"],
+                    "action_chunk": action_chunk.astype("float32"),
+                    "support_mode": int(privileged_state["support_mode"]),
+                    "phase": int(privileged_state.get("phase_label", 0)),
+                    "subgoal_progress": float(privileged_state.get("subgoal_progress", 0.0)),
+                    "corridor_feasible": privileged_state["corridor_feasible"].astype("float32"),
+                    "persistence_horizon": privileged_state["persistence_horizon"].astype("float32"),
+                    "disturbance_cost": float(privileged_state["disturbance_cost"]),
+                    "belief_map": privileged_state["belief_map"].astype("float32"),
+                    "visibility_map": privileged_state["visibility_map"].astype("float32"),
+                    "clearance_map": privileged_state["clearance_map"].astype("float32"),
+                    "occluder_contact_map": privileged_state["occluder_contact_map"].astype("float32"),
+                    "grasp_affordance_map": privileged_state["grasp_affordance_map"].astype("float32"),
+                    "support_stability": float(privileged_state["support_stability"]),
+                    "support_stability_map": privileged_state["support_stability_map"].astype("float32"),
+                    "reocclusion_target": float(privileged_state["reocclusion_target"]),
+                    "reocclusion_map": privileged_state["reocclusion_map"].astype("float32"),
+                    "gap_width": float(privileged_state.get("gap_width", 0.0)),
+                    "damage_proxy": float(privileged_state.get("damage_proxy", 0.0)),
+                    "release_collapse_rate": float(privileged_state.get("release_collapse_rate", 0.0)),
+                    "target_visibility_confidence": float(privileged_state.get("target_visibility_confidence", 0.0)),
+                    "mouth_aperture": float(privileged_state.get("mouth_aperture", 0.0)),
+                    "hold_quality": float(privileged_state.get("hold_quality", 0.0)),
+                    "rim_slip_risk": float(privileged_state.get("rim_slip_risk", 0.0)),
+                    "insertable_actor_corridor": float(privileged_state.get("insertable_actor_corridor", 0.0)),
+                    "layer_separation_quality": float(privileged_state.get("layer_separation_quality", 0.0)),
+                    "fold_preservation": float(privileged_state.get("fold_preservation", 0.0)),
+                    "insertion_corridor": float(privileged_state.get("insertion_corridor", 0.0)),
+                    "top_layer_stability": float(privileged_state.get("top_layer_stability", 0.0)),
+                    "lift_too_much_risk": float(privileged_state.get("lift_too_much_risk", 0.0)),
+                    "rollout_support_mode": rollout["rollout_support_mode"].astype("int64"),
+                    "rollout_phase": rollout.get("rollout_phase", np.zeros((rollout["rollout_support_mode"].shape[0],), dtype=np.int64)).astype("int64"),
+                    "rollout_corridor_feasible": rollout["rollout_corridor_feasible"].astype("float32"),
+                    "rollout_persistence_horizon": rollout["rollout_persistence_horizon"].astype("float32"),
+                    "rollout_disturbance_cost": rollout["rollout_disturbance_cost"].astype("float32"),
+                    "rollout_belief_map": rollout["rollout_belief_map"].astype("float32"),
+                    "rollout_visibility_map": rollout["rollout_visibility_map"].astype("float32"),
+                    "rollout_clearance_map": rollout["rollout_clearance_map"].astype("float32"),
+                    "rollout_support_stability": rollout["rollout_support_stability"].astype("float32"),
+                    "rollout_reocclusion_target": rollout["rollout_reocclusion_target"].astype("float32"),
+                    "rollout_occluder_contact_map": rollout["rollout_occluder_contact_map"].astype("float32"),
+                    "rollout_grasp_affordance_map": rollout["rollout_grasp_affordance_map"].astype("float32"),
+                    "history_render_states": padded_history_render_states,
+                    "history_proprio": np.stack(padded_history_proprio, axis=0).astype("float32")
+                    if padded_history_proprio
+                    else np.zeros((0, observation["proprio"].shape[0]), dtype=np.float32),
+                    "history_actions": np.stack(padded_history_actions, axis=0).astype("float32")
+                    if padded_history_actions
+                    else np.zeros((0, action_chunk.shape[-1]), dtype=np.float32),
+                    "history_camera_intrinsics": np.stack(padded_history_camera_intrinsics, axis=0).astype("float32")
+                    if padded_history_camera_intrinsics
+                    else np.zeros((0, 3, 3, 3), dtype=np.float32),
+                    "history_camera_extrinsics": np.stack(padded_history_camera_extrinsics, axis=0).astype("float32")
+                    if padded_history_camera_extrinsics
+                    else np.zeros((0, 3, 4, 4), dtype=np.float32),
+                    "history_camera_valid_mask": np.stack(padded_history_camera_valid_mask, axis=0).astype("float32")
+                    if padded_history_camera_valid_mask
+                    else np.zeros((0, 3), dtype=np.float32),
+                    "candidate_action_chunks": candidate_action_chunks.astype("float32"),
+                    **candidate_outcomes,
+                }
+                if proposal_target_builder is not None:
+                    extra_fields = proposal_target_builder(env, observation, sample)
+                    if extra_fields:
+                        sample.update(extra_fields)
+                samples.append(sample)
+                proxy_samples += 1
+                executed_action = env.teacher_action().astype("float32")
+                _, _, terminated, truncated, privileged_state = env.step(executed_action)
+                history_buffer.append(
+                    {
+                        "render_state": env.render_state(privileged_state),
+                        "proprio": env.get_observation(privileged_state)["proprio"].astype("float32"),
+                        "action": executed_action,
+                        "camera_intrinsics": env.get_observation(privileged_state).get("camera_intrinsics", default_camera_matrices()[0]).astype("float32"),
+                        "camera_extrinsics": env.get_observation(privileged_state).get("camera_extrinsics", default_camera_matrices()[1]).astype("float32"),
+                        "camera_valid_mask": env.get_observation(privileged_state).get("camera_valid_mask", np.ones((3,), dtype=np.float32)).astype("float32"),
+                    }
+                )
+                if terminated:
+                    proxy_success += 1
+                if terminated or truncated:
+                    break
+        summary[proxy_name] = {
+            "episodes": float(len(proxy_specs)),
+            "samples": float(proxy_samples),
+            "teacher_success": proxy_success / float(max(1, len(proxy_specs))),
+        }
+    return {
+        "dataset_version": dataset_version,
+        "resolution": resolution,
+        "chunk_horizon": chunk_horizon,
+        "rollout_horizon": rollout_horizon,
+        "history_steps": history_steps,
+        "planner_candidates": planner_candidates,
+        "episode_specs": resolved_episode_specs,
+        "samples": samples,
+        "summary": summary,
+    }
+
+
+def save_teacher_dataset(output_path: str | Path, dataset_bundle: dict[str, Any]) -> Path:
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(dataset_bundle, output_path)
+    return output_path
+
+
+def load_teacher_dataset(dataset_path: str | Path) -> dict[str, Any]:
+    return torch.load(Path(dataset_path), map_location="cpu", weights_only=False)
+
+
+class RevealOfflineDataset(Dataset[dict[str, Any]]):
+    def __init__(self, samples: Sequence[dict[str, Any]], resolution: int = 96) -> None:
+        self.samples = list(samples)
+        self.resolution = resolution
+        self._render_cache: dict[bytes, dict[str, np.ndarray]] = {}
+        self._item_cache: dict[int, dict[str, Any]] = {}
+
+    def __len__(self) -> int:
+        return len(self.samples)
+
+    def _render_cache_key(self, sample: dict[str, Any], render_state: dict[str, Any]) -> bytes:
+        include_depth = dataset_uses_rgbd(sample.get("dataset_version"))
+        return pickle.dumps(
+            (sample["proxy_name"], self.resolution, include_depth, render_state),
+            protocol=4,
+        )
+
+    def _render_sample(self, sample: dict[str, Any], render_state: dict[str, Any]) -> dict[str, np.ndarray]:
+        cache_key = self._render_cache_key(sample, render_state)
+        cached = self._render_cache.get(cache_key)
+        if cached is not None:
+            return cached
+        include_depth = dataset_uses_rgbd(sample.get("dataset_version"))
+        rendered = render_views_from_state(
+            proxy_name=sample["proxy_name"],
+            render_state=render_state,
+            resolution=self.resolution,
+            include_depth=include_depth,
+        )
+        self._render_cache[cache_key] = rendered
+        return rendered
+
+    def __getitem__(self, index: int) -> dict[str, Any]:
+        cached_item = self._item_cache.get(index)
+        if cached_item is not None:
+            return cached_item
+        sample = self.samples[index]
+        _assert_noleak_sample(sample)
+        candidate_count = int(sample.get("candidate_action_chunks", np.zeros((0, 0, 0), dtype=np.float32)).shape[0])
+        proposal_target_count = int(
+            sample.get("proposal_target_action_chunks", np.zeros((0, 0, 0), dtype=np.float32)).shape[0]
+        )
+        images = self._render_sample(sample, sample["render_state"])
+        history_images = []
+        history_depths = []
+        history_depth_valid = []
+        for history_state in sample.get("history_render_states", []):
+            rendered = self._render_sample(sample, history_state)
+            history_images.append(
+                torch.stack(
+                    [
+                        torch.from_numpy(rendered["front"]),
+                        torch.from_numpy(rendered["wrist_left"]),
+                        torch.from_numpy(rendered["wrist_right"]),
+                    ],
+                    dim=0,
+                )
+            )
+            if dataset_uses_rgbd(sample.get("dataset_version")):
+                history_depths.append(
+                    torch.stack(
+                        [
+                            torch.from_numpy(rendered["front_depth"]),
+                            torch.from_numpy(rendered["wrist_left_depth"]),
+                            torch.from_numpy(rendered["wrist_right_depth"]),
+                        ],
+                        dim=0,
+                    )
+                )
+                history_depth_valid.append(
+                    torch.stack(
+                        [
+                            torch.from_numpy(rendered["front_depth_valid"]),
+                            torch.from_numpy(rendered["wrist_left_depth_valid"]),
+                            torch.from_numpy(rendered["wrist_right_depth_valid"]),
+                        ],
+                        dim=0,
+                    )
+                )
+        stacked = torch.from_numpy(
+            torch.stack(
+                [
+                    torch.from_numpy(images["front"]),
+                    torch.from_numpy(images["wrist_left"]),
+                    torch.from_numpy(images["wrist_right"]),
+                ],
+                dim=0,
+            ).numpy()
+        ).permute(0, 3, 1, 2).float() / 255.0
+        if history_images:
+            history_stacked = torch.stack(history_images, dim=0).permute(0, 1, 4, 2, 3).float() / 255.0
+        else:
+            history_stacked = torch.zeros((0, 3, 3, self.resolution, self.resolution), dtype=torch.float32)
+        if dataset_uses_rgbd(sample.get("dataset_version")):
+            depths = torch.stack(
+                [
+                    torch.from_numpy(images["front_depth"]),
+                    torch.from_numpy(images["wrist_left_depth"]),
+                    torch.from_numpy(images["wrist_right_depth"]),
+                ],
+                dim=0,
+            ).unsqueeze(1).float()
+            depth_valid = torch.stack(
+                [
+                    torch.from_numpy(images["front_depth_valid"]),
+                    torch.from_numpy(images["wrist_left_depth_valid"]),
+                    torch.from_numpy(images["wrist_right_depth_valid"]),
+                ],
+                dim=0,
+            ).unsqueeze(1).float()
+            if history_depths:
+                history_depths_tensor = torch.stack(history_depths, dim=0).unsqueeze(2).float()
+                history_depth_valid_tensor = torch.stack(history_depth_valid, dim=0).unsqueeze(2).float()
+            else:
+                history_depths_tensor = torch.zeros((0, 3, 1, self.resolution, self.resolution), dtype=torch.float32)
+                history_depth_valid_tensor = torch.zeros((0, 3, 1, self.resolution, self.resolution), dtype=torch.float32)
+        else:
+            depths = torch.zeros((3, 1, self.resolution, self.resolution), dtype=torch.float32)
+            depth_valid = torch.zeros_like(depths)
+            history_depths_tensor = torch.zeros((0, 3, 1, self.resolution, self.resolution), dtype=torch.float32)
+            history_depth_valid_tensor = torch.zeros_like(history_depths_tensor)
+        camera_intrinsics = sample.get("camera_intrinsics")
+        camera_extrinsics = sample.get("camera_extrinsics")
+        camera_valid_mask = sample.get("camera_valid_mask")
+        if camera_intrinsics is None or camera_extrinsics is None:
+            default_intrinsics, default_extrinsics = default_camera_matrices()
+            camera_intrinsics = default_intrinsics
+            camera_extrinsics = default_extrinsics
+        if camera_valid_mask is None:
+            camera_valid_mask = np.ones((3,), dtype=np.float32)
+        history_length = len(sample.get("history_render_states", []))
+        history_camera_intrinsics = torch.as_tensor(
+            sample.get("history_camera_intrinsics", np.zeros((history_length, 3, 3, 3), dtype=np.float32)),
+            dtype=torch.float32,
+        )
+        history_camera_extrinsics = torch.as_tensor(
+            sample.get("history_camera_extrinsics", np.zeros((history_length, 3, 4, 4), dtype=np.float32)),
+            dtype=torch.float32,
+        )
+        history_camera_valid_mask = torch.as_tensor(
+            sample.get("history_camera_valid_mask", np.zeros((history_length, 3), dtype=np.float32)),
+            dtype=torch.float32,
+        )
+        item = {
+            "images": stacked,
+            "depths": depths,
+            "depth_valid": depth_valid,
+            "history_images": history_stacked,
+            "history_depths": history_depths_tensor,
+            "history_depth_valid": history_depth_valid_tensor,
+            "history_camera_intrinsics": history_camera_intrinsics,
+            "history_camera_extrinsics": history_camera_extrinsics,
+            "history_camera_valid_mask": history_camera_valid_mask,
+            "history_proprio": torch.as_tensor(sample.get("history_proprio", []), dtype=torch.float32),
+            "history_actions": torch.as_tensor(
+                sample.get(
+                    "history_actions",
+                    np.zeros((len(sample.get("history_render_states", [])), sample["action_chunk"].shape[-1]), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            ),
+            "camera_intrinsics": torch.as_tensor(camera_intrinsics, dtype=torch.float32),
+            "camera_extrinsics": torch.as_tensor(camera_extrinsics, dtype=torch.float32),
+            "camera_valid_mask": torch.as_tensor(camera_valid_mask, dtype=torch.float32),
+            "proprio": torch.as_tensor(sample["proprio"], dtype=torch.float32),
+            "texts": sample["language_goal"],
+            "task_name": sample.get("task_name", task_name_from_proxy_name(sample["proxy_name"])),
+            "task_id": torch.as_tensor(
+                sample.get(
+                    "task_id",
+                    task_id_from_task_name(sample.get("task_name", task_name_from_proxy_name(sample["proxy_name"]))),
+                ),
+                dtype=torch.long,
+            ),
+            "stress_slice": sample.get("stress_slice", "nominal"),
+            "difficulty_bin": sample.get("difficulty_bin", "medium"),
+            "episode_metadata_json": str(sample.get("episode_metadata", {})),
+            "action_chunk": torch.as_tensor(sample["action_chunk"], dtype=torch.float32),
+            "support_mode": torch.as_tensor(sample["support_mode"], dtype=torch.long),
+            "phase": torch.as_tensor(sample.get("phase", 0), dtype=torch.long),
+            "subgoal_progress": torch.as_tensor(sample.get("subgoal_progress", 0.0), dtype=torch.float32),
+            "corridor_feasible": torch.as_tensor(sample["corridor_feasible"], dtype=torch.float32),
+            "persistence_horizon": torch.as_tensor(sample["persistence_horizon"], dtype=torch.float32),
+            "disturbance_cost": torch.as_tensor(sample["disturbance_cost"], dtype=torch.float32),
+            "belief_map": torch.as_tensor(sample["belief_map"], dtype=torch.float32).unsqueeze(0),
+            "visibility_map": torch.as_tensor(sample.get("visibility_map", np.zeros((32, 32), dtype=np.float32)), dtype=torch.float32).unsqueeze(0),
+            "clearance_map": torch.as_tensor(sample.get("clearance_map", np.zeros((2, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "occluder_contact_map": torch.as_tensor(sample.get("occluder_contact_map", np.zeros((32, 32), dtype=np.float32)), dtype=torch.float32).unsqueeze(0),
+            "grasp_affordance_map": torch.as_tensor(sample.get("grasp_affordance_map", np.zeros((32, 32), dtype=np.float32)), dtype=torch.float32).unsqueeze(0),
+            "support_stability": torch.as_tensor(sample.get("support_stability", 0.0), dtype=torch.float32),
+            "support_stability_map": torch.as_tensor(sample.get("support_stability_map", np.zeros((32, 32), dtype=np.float32)), dtype=torch.float32).unsqueeze(0),
+            "reocclusion_target": torch.as_tensor(sample.get("reocclusion_target", 0.0), dtype=torch.float32),
+            "reocclusion_map": torch.as_tensor(sample.get("reocclusion_map", np.zeros((32, 32), dtype=np.float32)), dtype=torch.float32).unsqueeze(0),
+            "gap_width": torch.as_tensor(sample.get("gap_width", 0.0), dtype=torch.float32),
+            "damage_proxy": torch.as_tensor(sample.get("damage_proxy", 0.0), dtype=torch.float32),
+            "release_collapse_rate": torch.as_tensor(sample.get("release_collapse_rate", 0.0), dtype=torch.float32),
+            "target_visibility_confidence": torch.as_tensor(sample.get("target_visibility_confidence", 0.0), dtype=torch.float32),
+            "mouth_aperture": torch.as_tensor(sample.get("mouth_aperture", 0.0), dtype=torch.float32),
+            "hold_quality": torch.as_tensor(sample.get("hold_quality", 0.0), dtype=torch.float32),
+            "rim_slip_risk": torch.as_tensor(sample.get("rim_slip_risk", 0.0), dtype=torch.float32),
+            "insertable_actor_corridor": torch.as_tensor(sample.get("insertable_actor_corridor", 0.0), dtype=torch.float32),
+            "layer_separation_quality": torch.as_tensor(sample.get("layer_separation_quality", 0.0), dtype=torch.float32),
+            "fold_preservation": torch.as_tensor(sample.get("fold_preservation", 0.0), dtype=torch.float32),
+            "insertion_corridor": torch.as_tensor(sample.get("insertion_corridor", 0.0), dtype=torch.float32),
+            "top_layer_stability": torch.as_tensor(sample.get("top_layer_stability", 0.0), dtype=torch.float32),
+            "lift_too_much_risk": torch.as_tensor(sample.get("lift_too_much_risk", 0.0), dtype=torch.float32),
+            "rollout_support_mode": torch.as_tensor(sample["rollout_support_mode"], dtype=torch.long),
+            "rollout_phase": torch.as_tensor(sample.get("rollout_phase", np.zeros((0,), dtype=np.int64)), dtype=torch.long),
+            "rollout_corridor_feasible": torch.as_tensor(sample["rollout_corridor_feasible"], dtype=torch.float32),
+            "rollout_persistence_horizon": torch.as_tensor(sample["rollout_persistence_horizon"], dtype=torch.float32),
+            "rollout_disturbance_cost": torch.as_tensor(sample["rollout_disturbance_cost"], dtype=torch.float32),
+            "rollout_belief_map": torch.as_tensor(sample.get("rollout_belief_map", np.zeros((0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "rollout_visibility_map": torch.as_tensor(sample.get("rollout_visibility_map", np.zeros((0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "rollout_clearance_map": torch.as_tensor(sample.get("rollout_clearance_map", np.zeros((0, 2, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "rollout_support_stability": torch.as_tensor(sample.get("rollout_support_stability", np.zeros((0,), dtype=np.float32)), dtype=torch.float32),
+            "rollout_reocclusion_target": torch.as_tensor(sample.get("rollout_reocclusion_target", np.zeros((0,), dtype=np.float32)), dtype=torch.float32),
+            "rollout_occluder_contact_map": torch.as_tensor(sample.get("rollout_occluder_contact_map", np.zeros((0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "rollout_grasp_affordance_map": torch.as_tensor(sample.get("rollout_grasp_affordance_map", np.zeros((0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "candidate_action_chunks": torch.as_tensor(sample["candidate_action_chunks"], dtype=torch.float32),
+            "candidate_rollout_support_mode": torch.as_tensor(sample["candidate_rollout_support_mode"], dtype=torch.long),
+            "candidate_rollout_phase": torch.as_tensor(sample.get("candidate_rollout_phase", np.zeros((0, 0), dtype=np.int64)), dtype=torch.long),
+            "candidate_rollout_corridor_feasible": torch.as_tensor(sample["candidate_rollout_corridor_feasible"], dtype=torch.float32),
+            "candidate_rollout_persistence_horizon": torch.as_tensor(sample["candidate_rollout_persistence_horizon"], dtype=torch.float32),
+            "candidate_rollout_disturbance_cost": torch.as_tensor(sample["candidate_rollout_disturbance_cost"], dtype=torch.float32),
+            "candidate_rollout_belief_map": torch.as_tensor(sample.get("candidate_rollout_belief_map", np.zeros((0, 0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rollout_visibility_map": torch.as_tensor(sample.get("candidate_rollout_visibility_map", np.zeros((0, 0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rollout_clearance_map": torch.as_tensor(sample.get("candidate_rollout_clearance_map", np.zeros((0, 0, 2, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rollout_support_stability": torch.as_tensor(sample.get("candidate_rollout_support_stability", np.zeros((0, 0), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rollout_reocclusion_target": torch.as_tensor(sample.get("candidate_rollout_reocclusion_target", np.zeros((0, 0), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rollout_occluder_contact_map": torch.as_tensor(sample.get("candidate_rollout_occluder_contact_map", np.zeros((0, 0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rollout_grasp_affordance_map": torch.as_tensor(sample.get("candidate_rollout_grasp_affordance_map", np.zeros((0, 0, 32, 32), dtype=np.float32)), dtype=torch.float32),
+            "candidate_retrieval_success": torch.as_tensor(sample["candidate_retrieval_success"], dtype=torch.float32),
+            "candidate_final_disturbance_cost": torch.as_tensor(sample["candidate_final_disturbance_cost"], dtype=torch.float32),
+            "candidate_reocclusion_rate": torch.as_tensor(sample["candidate_reocclusion_rate"], dtype=torch.float32),
+            "candidate_visibility_integral": torch.as_tensor(sample["candidate_visibility_integral"], dtype=torch.float32),
+            "candidate_actor_feasibility_auc": torch.as_tensor(sample.get("candidate_actor_feasibility_auc", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_reveal_achieved": torch.as_tensor(sample.get("candidate_reveal_achieved", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_hold_persistence": torch.as_tensor(sample.get("candidate_hold_persistence", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_support_stability_auc": torch.as_tensor(sample.get("candidate_support_stability_auc", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_disturbance_auc": torch.as_tensor(sample.get("candidate_disturbance_auc", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_macro_ids": torch.as_tensor(sample.get("candidate_macro_ids", np.zeros((candidate_count,), dtype=np.int64)), dtype=torch.long),
+            "candidate_is_hard_negative": torch.as_tensor(sample.get("candidate_is_hard_negative", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_risk": torch.as_tensor(sample["candidate_risk"], dtype=torch.float32),
+            "candidate_utility": torch.as_tensor(sample["candidate_utility"], dtype=torch.float32),
+            "candidate_gap_width": torch.as_tensor(sample.get("candidate_gap_width", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_damage_proxy": torch.as_tensor(sample.get("candidate_damage_proxy", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_mouth_aperture": torch.as_tensor(sample.get("candidate_mouth_aperture", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_hold_quality": torch.as_tensor(sample.get("candidate_hold_quality", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_rim_slip_risk": torch.as_tensor(sample.get("candidate_rim_slip_risk", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_fold_preservation": torch.as_tensor(sample.get("candidate_fold_preservation", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_layer_separation_quality": torch.as_tensor(sample.get("candidate_layer_separation_quality", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "candidate_lift_too_much_risk": torch.as_tensor(sample.get("candidate_lift_too_much_risk", np.zeros((candidate_count,), dtype=np.float32)), dtype=torch.float32),
+            "proxy_name": sample["proxy_name"],
+            "episode_id": sample["episode_id"],
+        }
+        if "proposal_target_action_chunks" in sample:
+            rollout_horizon = int(np.asarray(sample.get("rollout_support_mode", np.zeros((0,), dtype=np.int64))).shape[0])
+            belief_map_shape = tuple(np.asarray(sample.get("rollout_belief_map", np.zeros((0, 32, 32), dtype=np.float32))).shape[1:])
+            visibility_map_shape = tuple(np.asarray(sample.get("rollout_visibility_map", np.zeros((0, 32, 32), dtype=np.float32))).shape[1:])
+            clearance_map_shape = tuple(np.asarray(sample.get("rollout_clearance_map", np.zeros((0, 2, 32, 32), dtype=np.float32))).shape[1:])
+            occluder_contact_shape = tuple(
+                np.asarray(sample.get("rollout_occluder_contact_map", np.zeros((0, 32, 32), dtype=np.float32))).shape[1:]
+            )
+            grasp_affordance_shape = tuple(
+                np.asarray(sample.get("rollout_grasp_affordance_map", np.zeros((0, 32, 32), dtype=np.float32))).shape[1:]
+            )
+            item["proposal_target_action_chunks"] = torch.as_tensor(sample["proposal_target_action_chunks"], dtype=torch.float32)
+            item["proposal_target_retrieval_success"] = torch.as_tensor(
+                sample.get("proposal_target_retrieval_success", np.zeros((proposal_target_count,), dtype=np.float32)),
+                dtype=torch.float32,
+            )
+            item["proposal_target_risk"] = torch.as_tensor(
+                sample.get("proposal_target_risk", np.zeros((proposal_target_count,), dtype=np.float32)),
+                dtype=torch.float32,
+            )
+            item["proposal_target_utility"] = torch.as_tensor(
+                sample.get("proposal_target_utility", np.zeros((proposal_target_count,), dtype=np.float32)),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_support_mode"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_support_mode",
+                    np.zeros((proposal_target_count, rollout_horizon), dtype=np.int64),
+                ),
+                dtype=torch.long,
+            )
+            item["proposal_target_rollout_phase"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_phase",
+                    np.zeros((proposal_target_count, rollout_horizon), dtype=np.int64),
+                ),
+                dtype=torch.long,
+            )
+            item["proposal_target_rollout_corridor_feasible"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_corridor_feasible",
+                    np.zeros((proposal_target_count, rollout_horizon, 3), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_persistence_horizon"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_persistence_horizon",
+                    np.zeros((proposal_target_count, rollout_horizon, 3), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_disturbance_cost"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_disturbance_cost",
+                    np.zeros((proposal_target_count, rollout_horizon), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_belief_map"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_belief_map",
+                    np.zeros((proposal_target_count, rollout_horizon, *belief_map_shape), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_visibility_map"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_visibility_map",
+                    np.zeros((proposal_target_count, rollout_horizon, *visibility_map_shape), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_clearance_map"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_clearance_map",
+                    np.zeros((proposal_target_count, rollout_horizon, *clearance_map_shape), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_support_stability"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_support_stability",
+                    np.zeros((proposal_target_count, rollout_horizon), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_reocclusion_target"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_reocclusion_target",
+                    np.zeros((proposal_target_count, rollout_horizon), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_occluder_contact_map"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_occluder_contact_map",
+                    np.zeros((proposal_target_count, rollout_horizon, *occluder_contact_shape), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+            item["proposal_target_rollout_grasp_affordance_map"] = torch.as_tensor(
+                sample.get(
+                    "proposal_target_rollout_grasp_affordance_map",
+                    np.zeros((proposal_target_count, rollout_horizon, *grasp_affordance_shape), dtype=np.float32),
+                ),
+                dtype=torch.float32,
+            )
+        self._item_cache[index] = item
+        return item
+
+
+def dataset_from_bundle(dataset_bundle: dict[str, Any], resolution: int | None = None) -> RevealOfflineDataset:
+    resolution = resolution or int(dataset_bundle["resolution"])
+    return RevealOfflineDataset(dataset_bundle["samples"], resolution=resolution)

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/generate_dataset.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from sim_reveal.dataset import collect_teacher_dataset, save_teacher_dataset
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--proxies", nargs="*", default=None)
+    parser.add_argument("--episodes-per-proxy", type=int, default=32)
+    parser.add_argument("--resolution", type=int, default=96)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--chunk-horizon", type=int, default=8)
+    parser.add_argument("--rollout-horizon", type=int, default=5)
+    parser.add_argument("--history-steps", type=int, default=2)
+    parser.add_argument("--planner-candidates", type=int, default=4)
+    parser.add_argument("--episode-spec-path", default=None)
+    parser.add_argument("--output-path", default="/workspace/data/reveal_proxy/reveal_proxy_teacher.pt")
+    args = parser.parse_args()
+    episode_specs = None
+    if args.episode_spec_path:
+        episode_specs = json.loads(Path(args.episode_spec_path).read_text(encoding="utf-8"))
+
+    dataset_bundle = collect_teacher_dataset(
+        proxy_names=args.proxies,
+        episodes_per_proxy=args.episodes_per_proxy,
+        resolution=args.resolution,
+        seed=args.seed,
+        chunk_horizon=args.chunk_horizon,
+        rollout_horizon=args.rollout_horizon,
+        history_steps=args.history_steps,
+        planner_candidates=args.planner_candidates,
+        episode_specs=episode_specs,
+    )
+    output_path = save_teacher_dataset(Path(args.output_path), dataset_bundle)
+    payload = {
+        "output_path": str(output_path),
+        "resolution": dataset_bundle["resolution"],
+        "num_samples": len(dataset_bundle["samples"]),
+        "num_episode_specs": len(dataset_bundle.get("episode_specs", [])),
+        "summary": dataset_bundle["summary"],
+    }
+    print(json.dumps(payload, indent=2))
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/isaac_smoke.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+from sim_reveal.isaac_wrapper import IsaacRevealRuntime
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--visible", action="store_true")
+    args = parser.parse_args()
+
+    runtime = IsaacRevealRuntime(headless=not args.visible)
+    try:
+        import isaacsim
+
+        payload = {
+            "headless": not args.visible,
+            "isaacsim_version": getattr(isaacsim, "__version__", "unknown"),
+            "status": "ok",
+        }
+        print(json.dumps(payload, indent=2))
+    finally:
+        runtime.close()
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/isaac_wrapper.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class IsaacRevealRuntime:
+    headless: bool = True
+
+    def __post_init__(self) -> None:
+        from isaacsim import SimulationApp
+
+        self._simulation_app = SimulationApp({"headless": self.headless})
+
+    def close(self) -> None:
+        self._simulation_app.close()

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/labels.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from sim_reveal.base import RevealState, SupportMode
+
+
+def privileged_state_to_reveal_labels(
+    state: dict[str, Any],
+    num_modes: int = 3,
+    num_templates: int = 32,
+    rollout_horizon: int = 5,
+) -> RevealState:
+    support_mode = int(state["support_mode"])
+    support_logits = np.full((num_modes,), -4.0, dtype=np.float32)
+    support_logits[support_mode] = 4.0
+
+    corridor = np.asarray(state["corridor_feasible"], dtype=np.float32)
+    if corridor.shape != (num_modes, num_templates):
+        raise ValueError(
+            f"Expected corridor_feasible shape {(num_modes, num_templates)}, got {corridor.shape}"
+        )
+    corridor_logits = np.where(corridor > 0.5, 4.0, -4.0).astype(np.float32)
+
+    persistence = np.asarray(state["persistence_horizon"], dtype=np.float32)
+    if persistence.shape != (num_modes,):
+        raise ValueError(f"Expected persistence_horizon shape {(num_modes,)}, got {persistence.shape}")
+    persistence = np.clip(persistence, 0.0, float(rollout_horizon))
+
+    disturbance = np.asarray([state["disturbance_cost"]], dtype=np.float32)
+    belief_map = state.get("belief_map")
+    if belief_map is not None:
+        belief_map = np.asarray(belief_map, dtype=np.float32)
+
+    return RevealState(
+        support_mode_logits=support_logits,
+        corridor_logits=corridor_logits,
+        persistence_horizon=persistence,
+        disturbance_cost=disturbance,
+        belief_map=belief_map,
+    )
+
+
+def reocclusion_rate(corridor_open_history: np.ndarray) -> float:
+    corridor_open_history = np.asarray(corridor_open_history, dtype=np.float32)
+    if corridor_open_history.ndim != 1:
+        raise ValueError("corridor_open_history must be 1D.")
+    if corridor_open_history.size < 2:
+        return 0.0
+    open_then_closed = np.logical_and(corridor_open_history[:-1] > 0.5, corridor_open_history[1:] <= 0.5)
+    return float(open_then_closed.mean())
+
+
+def infer_support_mode_from_flags(holding: bool, transferred: bool) -> SupportMode:
+    if holding:
+        return SupportMode.HOLD
+    if transferred:
+        return SupportMode.TRANSFER
+    return SupportMode.PASSIVE

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/procedural_envs.py

@@ -0,0 +1,1389 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from sim_reveal.base import RevealProxyConfig, SupportMode
+from sim_reveal.proxy_specs import (
+    BAG_PROXY,
+    CLOTH_PROXY,
+    CRITICAL_STRESS_BY_TASK_NAME,
+    FOLIAGE_PROXY,
+    SPRINT_DIFFICULTY_BINS,
+    task_id_from_task_name,
+    task_name_from_proxy_name,
+)
+
+
+@dataclass(frozen=True)
+class ProxyDynamics:
+    hold_decay: float
+    transfer_decay: float
+    passive_decay: float
+    disturbance_gain: float
+    settle_rate: float
+    desired_opening: float
+    preferred_mode: SupportMode
+    transfer_support_factor: float
+    passive_support_factor: float
+    visibility_bias: float
+    retrieve_visibility_threshold: float
+    palette: tuple[float, float, float]
+
+
+PROXY_CONFIGS: dict[str, RevealProxyConfig] = {
+    FOLIAGE_PROXY.name: FOLIAGE_PROXY,
+    BAG_PROXY.name: BAG_PROXY,
+    CLOTH_PROXY.name: CLOTH_PROXY,
+}
+
+PROXY_DYNAMICS: dict[str, ProxyDynamics] = {
+    FOLIAGE_PROXY.name: ProxyDynamics(
+        hold_decay=0.02,
+        transfer_decay=0.07,
+        passive_decay=0.15,
+        disturbance_gain=0.06,
+        settle_rate=0.03,
+        desired_opening=0.60,
+        preferred_mode=SupportMode.HOLD,
+        transfer_support_factor=0.76,
+        passive_support_factor=0.42,
+        visibility_bias=0.03,
+        retrieve_visibility_threshold=0.42,
+        palette=(0.16, 0.30, 0.12),
+    ),
+    BAG_PROXY.name: ProxyDynamics(
+        hold_decay=0.04,
+        transfer_decay=0.03,
+        passive_decay=0.12,
+        disturbance_gain=0.05,
+        settle_rate=0.02,
+        desired_opening=0.68,
+        preferred_mode=SupportMode.TRANSFER,
+        transfer_support_factor=0.96,
+        passive_support_factor=0.55,
+        visibility_bias=0.06,
+        retrieve_visibility_threshold=0.48,
+        palette=(0.26, 0.17, 0.10),
+    ),
+    CLOTH_PROXY.name: ProxyDynamics(
+        hold_decay=0.03,
+        transfer_decay=0.05,
+        passive_decay=0.04,
+        disturbance_gain=0.04,
+        settle_rate=0.04,
+        desired_opening=0.50,
+        preferred_mode=SupportMode.PASSIVE,
+        transfer_support_factor=0.82,
+        passive_support_factor=0.90,
+        visibility_bias=0.08,
+        retrieve_visibility_threshold=0.38,
+        palette=(0.24, 0.24, 0.29),
+    ),
+}
+
+PROXY_GOALS = {
+    FOLIAGE_PROXY.name: "create a gap in the foliage and retrieve the target",
+    BAG_PROXY.name: "open the bag mouth and retrieve the target object",
+    CLOTH_PROXY.name: "lift the top layer enough to retrieve the hidden object",
+}
+
+
+def default_camera_matrices(
+    pose_jitter: float = 0.0,
+    focal_jitter: float = 0.0,
+    lateral_skew: float = 0.0,
+) -> tuple[np.ndarray, np.ndarray]:
+    intrinsics = np.asarray(
+        [
+            [[140.0, 0.0, 48.0], [0.0, 140.0, 48.0], [0.0, 0.0, 1.0]],
+            [[135.0, 0.0, 48.0], [0.0, 135.0, 48.0], [0.0, 0.0, 1.0]],
+            [[135.0, 0.0, 48.0], [0.0, 135.0, 48.0], [0.0, 0.0, 1.0]],
+        ],
+        dtype=np.float32,
+    )
+    extrinsics = np.asarray(
+        [
+            np.eye(4, dtype=np.float32),
+            [[1.0, 0.0, 0.0, -0.18], [0.0, 1.0, 0.0, 0.04], [0.0, 0.0, 1.0, 0.10], [0.0, 0.0, 0.0, 1.0]],
+            [[1.0, 0.0, 0.0, 0.18], [0.0, 1.0, 0.0, 0.04], [0.0, 0.0, 1.0, 0.10], [0.0, 0.0, 0.0, 1.0]],
+        ],
+        dtype=np.float32,
+    )
+    if pose_jitter != 0.0:
+        extrinsics[1, 0, 3] -= 0.6 * pose_jitter
+        extrinsics[2, 0, 3] += 0.6 * pose_jitter
+        extrinsics[1, 1, 3] += 0.25 * pose_jitter + lateral_skew
+        extrinsics[2, 1, 3] += 0.25 * pose_jitter - lateral_skew
+        extrinsics[1, 2, 3] += 0.15 * pose_jitter
+        extrinsics[2, 2, 3] += 0.10 * pose_jitter
+    if focal_jitter != 0.0:
+        intrinsics[0, 0, 0] *= 1.0 + 0.10 * focal_jitter
+        intrinsics[0, 1, 1] *= 1.0 - 0.05 * focal_jitter
+        intrinsics[1, 0, 0] *= 1.0 - 0.08 * focal_jitter
+        intrinsics[2, 1, 1] *= 1.0 + 0.08 * focal_jitter
+        intrinsics[1, 0, 2] += 3.0 * focal_jitter + 6.0 * lateral_skew
+        intrinsics[2, 0, 2] -= 3.0 * focal_jitter - 6.0 * lateral_skew
+    return intrinsics, extrinsics
+
+
+def available_proxy_names() -> tuple[str, ...]:
+    return tuple(PROXY_CONFIGS.keys())
+
+
+def make_proxy_env(
+    proxy_name: str,
+    resolution: int = 96,
+    seed: int = 0,
+    num_templates: int = 32,
+    rollout_horizon: int = 5,
+    max_steps: int | None = None,
+    stress_slice: str = "nominal",
+    difficulty_bin: str = "medium",
+) -> "ProceduralRevealEnv":
+    return ProceduralRevealEnv(
+        proxy_name=proxy_name,
+        resolution=resolution,
+        seed=seed,
+        num_templates=num_templates,
+        rollout_horizon=rollout_horizon,
+        max_steps=max_steps,
+        stress_slice=stress_slice,
+        difficulty_bin=difficulty_bin,
+    )
+
+
+class ProceduralRevealEnv:
+    camera_names = ("front", "wrist_left", "wrist_right")
+
+    def __init__(
+        self,
+        proxy_name: str,
+        resolution: int = 96,
+        seed: int = 0,
+        num_templates: int = 32,
+        rollout_horizon: int = 5,
+        max_steps: int | None = None,
+        stress_slice: str = "nominal",
+        difficulty_bin: str = "medium",
+    ) -> None:
+        if proxy_name not in PROXY_CONFIGS:
+            raise KeyError(f"Unknown proxy: {proxy_name}")
+        if difficulty_bin not in SPRINT_DIFFICULTY_BINS:
+            raise ValueError(f"Unsupported difficulty bin: {difficulty_bin}")
+        self.proxy = PROXY_CONFIGS[proxy_name]
+        self.dynamics = PROXY_DYNAMICS[proxy_name]
+        self.proxy_name = proxy_name
+        self.task_name = task_name_from_proxy_name(proxy_name)
+        self.task_id = task_id_from_task_name(self.task_name)
+        self.critical_stress = CRITICAL_STRESS_BY_TASK_NAME[self.task_name]
+        self.stress_slice = str(stress_slice)
+        self.difficulty_bin = str(difficulty_bin)
+        self.resolution = resolution
+        self.num_templates = num_templates
+        self.rollout_horizon = rollout_horizon
+        self.max_steps = max_steps or self.proxy.max_steps
+        self.rng = np.random.default_rng(seed)
+        self.reset(seed=seed)
+
+    def clone_state(self) -> dict[str, Any]:
+        return {
+            "step_count": self.step_count,
+            "opening": self.opening,
+            "disturbance": self.disturbance,
+            "target_template": self.target_template,
+            "target_depth": self.target_depth,
+            "target_center": self.target_center,
+            "target_radius": self.target_radius,
+            "texture_phase": self.texture_phase,
+            "texture_scale": self.texture_scale,
+            "view_bias": self.view_bias,
+            "target_intensity": self.target_intensity,
+            "holding": self.holding,
+            "transferred": self.transferred,
+            "retrieved": self.retrieved,
+            "actor_progress": self.actor_progress,
+            "last_actor_template": self.last_actor_template,
+            "visibility_trace": list(self.visibility_trace),
+            "corridor_trace": list(self.corridor_trace),
+        }
+
+    def restore_state(self, state: dict[str, Any]) -> None:
+        self.step_count = int(state["step_count"])
+        self.opening = float(state["opening"])
+        self.disturbance = float(state["disturbance"])
+        self.target_template = int(state["target_template"])
+        self.target_depth = float(state["target_depth"])
+        self.target_center = float(state["target_center"])
+        self.target_radius = float(state["target_radius"])
+        self.texture_phase = float(state["texture_phase"])
+        self.texture_scale = float(state["texture_scale"])
+        self.view_bias = float(state["view_bias"])
+        self.target_intensity = float(state["target_intensity"])
+        self.holding = bool(state["holding"])
+        self.transferred = bool(state["transferred"])
+        self.retrieved = bool(state["retrieved"])
+        self.actor_progress = float(state["actor_progress"])
+        self.last_actor_template = int(state["last_actor_template"])
+        self.visibility_trace = list(state["visibility_trace"])
+        self.corridor_trace = list(state["corridor_trace"])
+
+    def _difficulty_ranges(self) -> dict[str, tuple[float, float]]:
+        if self.difficulty_bin == "hard":
+            return {
+                "opening": (0.07, 0.18),
+                "disturbance": (0.08, 0.18),
+                "target_depth": (0.28, 0.52),
+                "target_radius": (0.018, 0.030),
+                "view_bias": (-0.18, 0.18),
+            }
+        return {
+            "opening": (0.12, 0.24),
+            "disturbance": (0.03, 0.12),
+            "target_depth": (0.14, 0.40),
+            "target_radius": (0.022, 0.036),
+            "view_bias": (-0.10, 0.10),
+        }
+
+    def _stress_parameters(self) -> dict[str, float]:
+        params = {
+            "reocclusion_bias": 0.0,
+            "closure_scale": 1.0,
+            "disturbance_gain_scale": 1.0,
+            "corridor_scale": 1.0,
+            "support_stability_penalty": 0.0,
+            "camera_pose_jitter": 0.0,
+            "focal_jitter": 0.0,
+            "lateral_skew": 0.0,
+            "collateral_bias": 0.0,
+            "opening_shift": 0.0,
+            "disturbance_shift": 0.0,
+            "depth_shift": 0.0,
+            "view_bias_scale": 1.0,
+        }
+        if self.stress_slice == "high_reocclusion":
+            params.update(
+                {
+                    "reocclusion_bias": 0.18,
+                    "closure_scale": 1.22,
+                    "disturbance_gain_scale": 1.12,
+                    "opening_shift": -0.03,
+                }
+            )
+        elif self.stress_slice == "camera_perturbation":
+            params.update(
+                {
+                    "camera_pose_jitter": 1.0 if self.difficulty_bin == "hard" else 0.65,
+                    "focal_jitter": 0.9 if self.difficulty_bin == "hard" else 0.55,
+                    "lateral_skew": 0.06 if self.proxy_name == BAG_PROXY.name else 0.02,
+                    "view_bias_scale": 1.75 if self.difficulty_bin == "hard" else 1.4,
+                }
+            )
+        elif self.stress_slice == "tight_corridor_high_collateral":
+            params.update(
+                {
+                    "corridor_scale": 0.76,
+                    "disturbance_gain_scale": 1.25,
+                    "collateral_bias": 0.14,
+                    "support_stability_penalty": 0.08,
+                    "opening_shift": -0.04,
+                }
+            )
+        elif self.stress_slice == "one_sided_slip":
+            params.update(
+                {
+                    "corridor_scale": 0.84,
+                    "disturbance_gain_scale": 1.10,
+                    "reocclusion_bias": 0.10,
+                    "camera_pose_jitter": 0.45,
+                    "focal_jitter": 0.35,
+                    "lateral_skew": 0.10 if self.difficulty_bin == "hard" else 0.06,
+                }
+            )
+        elif self.stress_slice == "fold_sensitive_long_persistence":
+            params.update(
+                {
+                    "disturbance_gain_scale": 1.18,
+                    "support_stability_penalty": 0.12,
+                    "reocclusion_bias": 0.08,
+                    "collateral_bias": 0.12,
+                    "depth_shift": 0.04,
+                }
+            )
+        return params
+
+    def episode_metadata(self) -> dict[str, Any]:
+        return {
+            "proxy_name": self.proxy_name,
+            "task_name": self.task_name,
+            "task_id": self.task_id,
+            "stress_slice": self.stress_slice,
+            "difficulty_bin": self.difficulty_bin,
+            "camera_pose_jitter": float(self.camera_pose_jitter),
+            "focal_jitter": float(self.focal_jitter),
+            "lateral_skew": float(self.lateral_skew),
+            "reocclusion_bias": float(self.reocclusion_bias),
+            "closure_scale": float(self.closure_scale),
+            "disturbance_gain_scale": float(self.disturbance_gain_scale),
+            "corridor_scale": float(self.corridor_scale),
+            "support_stability_penalty": float(self.support_stability_penalty),
+            "collateral_bias": float(self.collateral_bias),
+        }
+
+    def reset(self, seed: int | None = None) -> tuple[dict[str, Any], dict[str, Any]]:
+        if seed is not None:
+            self.rng = np.random.default_rng(seed)
+        ranges = self._difficulty_ranges()
+        stress = self._stress_parameters()
+        self.reocclusion_bias = float(stress["reocclusion_bias"])
+        self.closure_scale = float(stress["closure_scale"])
+        self.disturbance_gain_scale = float(stress["disturbance_gain_scale"])
+        self.corridor_scale = float(stress["corridor_scale"])
+        self.support_stability_penalty = float(stress["support_stability_penalty"])
+        self.camera_pose_jitter = float(stress["camera_pose_jitter"])
+        self.focal_jitter = float(stress["focal_jitter"])
+        self.lateral_skew = float(stress["lateral_skew"])
+        self.collateral_bias = float(stress["collateral_bias"])
+        self.step_count = 0
+        self.opening = float(
+            np.clip(
+                self.rng.uniform(*ranges["opening"]) + stress["opening_shift"],
+                0.03,
+                0.95,
+            )
+        )
+        self.disturbance = float(
+            np.clip(
+                self.rng.uniform(*ranges["disturbance"]) + stress["disturbance_shift"],
+                0.0,
+                1.0,
+            )
+        )
+        self.target_template = int(self.rng.integers(4, self.num_templates - 4))
+        self.target_depth = float(
+            np.clip(
+                self.rng.uniform(*ranges["target_depth"]) + stress["depth_shift"],
+                0.05,
+                0.85,
+            )
+        )
+        base_center = self.target_template / float(max(1, self.num_templates - 1))
+        self.target_center = float(np.clip(base_center + self.rng.uniform(-0.01, 0.01), 0.06, 0.94))
+        self.target_radius = float(self.rng.uniform(*ranges["target_radius"]))
+        self.texture_phase = float(self.rng.uniform(0.0, 2.0 * np.pi))
+        self.texture_scale = float(self.rng.uniform(0.85, 1.25))
+        self.view_bias = float(
+            np.clip(
+                self.rng.uniform(*ranges["view_bias"]) * stress["view_bias_scale"],
+                -0.30,
+                0.30,
+            )
+        )
+        self.target_intensity = float(self.rng.uniform(0.45, 0.8))
+        self.holding = False
+        self.transferred = False
+        self.retrieved = False
+        self.actor_progress = 0.0
+        self.last_actor_template = self.target_template
+        privileged_state = self.get_privileged_state()
+        self.visibility_trace = [float(privileged_state["visibility"])]
+        self.corridor_trace = [float(privileged_state["corridor_feasible"][privileged_state["support_mode"]].any())]
+        return self.get_observation(privileged_state), privileged_state
+
+    def _normalized_template(self, template_index: int) -> float:
+        return (template_index / float(self.num_templates - 1)) * 2.0 - 1.0
+
+    def _current_support_mode(self) -> SupportMode:
+        if self.holding:
+            return SupportMode.HOLD
+        if self.transferred:
+            return SupportMode.TRANSFER
+        return SupportMode.PASSIVE
+
+    def _mode_from_action(self, action: np.ndarray) -> SupportMode:
+        hold_score = (np.tanh(float(action[6])) + 1.0) * 0.5
+        transfer_score = (np.tanh(float(action[1])) + 1.0) * 0.5
+        passive_score = (np.tanh(float(action[2])) + 1.0) * 0.5
+        if hold_score >= max(transfer_score, passive_score):
+            return SupportMode.HOLD
+        if transfer_score >= passive_score and self.opening >= 0.32:
+            return SupportMode.TRANSFER
+        return SupportMode.PASSIVE
+
+    def _visibility(self, opening: float | None = None, disturbance: float | None = None) -> float:
+        opening = self.opening if opening is None else float(opening)
+        disturbance = self.disturbance if disturbance is None else float(disturbance)
+        visibility = (
+            1.35 * opening
+            - 0.58 * disturbance
+            - 0.25 * self.target_depth
+            + self.dynamics.visibility_bias
+        )
+        return float(np.clip(visibility, 0.0, 1.0))
+
+    def _mode_factor(self, mode: SupportMode) -> float:
+        if mode == SupportMode.HOLD:
+            return 1.0
+        if mode == SupportMode.TRANSFER:
+            return self.dynamics.transfer_support_factor
+        return self.dynamics.passive_support_factor
+
+    def _mode_decay(self, mode: SupportMode) -> float:
+        if mode == SupportMode.HOLD:
+            return self.dynamics.hold_decay
+        if mode == SupportMode.TRANSFER:
+            return self.dynamics.transfer_decay
+        return self.dynamics.passive_decay
+
+    def _corridor_for_mode(
+        self,
+        mode: SupportMode,
+        opening: float | None = None,
+        disturbance: float | None = None,
+    ) -> np.ndarray:
+        opening = self.opening if opening is None else float(opening)
+        disturbance = self.disturbance if disturbance is None else float(disturbance)
+        visibility = self._visibility(opening, disturbance)
+        effective = (
+            self.corridor_scale * opening * self._mode_factor(mode)
+            - 0.35 * disturbance
+            - 0.18 * self.target_depth
+            - 0.10 * self.collateral_bias
+        )
+        width = int(np.floor(max(0.0, effective) * 8.0))
+        corridor = np.zeros((self.num_templates,), dtype=np.float32)
+        if visibility < self.dynamics.retrieve_visibility_threshold * 0.7 or width <= 0:
+            return corridor
+        low = max(0, self.target_template - width)
+        high = min(self.num_templates, self.target_template + width + 1)
+        corridor[low:high] = 1.0
+        return corridor
+
+    def _persistence_for_mode(self, mode: SupportMode) -> float:
+        opening = self.opening
+        disturbance = self.disturbance
+        persisted = 0.0
+        for _ in range(self.rollout_horizon):
+            if self._corridor_for_mode(mode, opening, disturbance).any():
+                persisted += 1.0
+            else:
+                break
+            opening = float(np.clip(opening - self._mode_decay(mode) + (0.035 if mode == SupportMode.HOLD else 0.0), 0.0, 1.0))
+            disturbance = float(np.clip(disturbance * (1.0 - self.dynamics.settle_rate), 0.0, 1.0))
+        return persisted
+
+    def _belief_map(self, visibility: float) -> np.ndarray:
+        side = 32
+        x = np.linspace(0.0, 1.0, side, dtype=np.float32)
+        y = np.linspace(0.0, 1.0, side, dtype=np.float32)
+        yy, xx = np.meshgrid(y, x, indexing="ij")
+        center_x = self.target_template / float(self.num_templates - 1)
+        center_y = 0.72 - 0.25 * self.target_depth
+        sigma = 0.08 + 0.05 * (1.0 - visibility)
+        belief = np.exp(-(((xx - center_x) ** 2) + ((yy - center_y) ** 2)) / (2.0 * sigma**2))
+        belief *= visibility
+        return belief.astype(np.float32)
+
+    def _visibility_map(self, visibility: float) -> np.ndarray:
+        belief = self._belief_map(visibility)
+        gradient = np.linspace(0.65, 1.0, belief.shape[0], dtype=np.float32).reshape(-1, 1)
+        return np.clip(belief * gradient, 0.0, 1.0).astype(np.float32)
+
+    def _clearance_map(self, visibility: float) -> np.ndarray:
+        side = 32
+        x = np.linspace(0.0, 1.0, side, dtype=np.float32)
+        y = np.linspace(0.0, 1.0, side, dtype=np.float32)
+        yy, xx = np.meshgrid(y, x, indexing="ij")
+        corridor_width = np.clip(0.05 + 0.18 * self.opening - 0.10 * self.disturbance, 0.01, 0.28)
+        corridor = np.exp(-(((xx - self.target_center) ** 2) / max(1e-5, corridor_width**2)))
+        vertical = np.exp(-(((yy - (0.72 - 0.25 * self.target_depth)) ** 2) / 0.03))
+        left = np.clip(corridor * vertical * visibility * (0.92 - 0.15 * self.disturbance), 0.0, 1.0)
+        right = np.clip(corridor * vertical * visibility * (0.88 - 0.10 * self.disturbance), 0.0, 1.0)
+        return np.stack([left, right], axis=0).astype(np.float32)
+
+    def _occluder_contact_map(self) -> np.ndarray:
+        side = 32
+        x = np.linspace(0.0, 1.0, side, dtype=np.float32)
+        y = np.linspace(0.0, 1.0, side, dtype=np.float32)
+        yy, xx = np.meshgrid(y, x, indexing="ij")
+        gap_width = np.clip(0.03 + 0.16 * self.opening, 0.03, 0.24)
+        left_band = np.exp(-(((xx - (self.target_center - gap_width)) ** 2) / 0.0025))
+        right_band = np.exp(-(((xx - (self.target_center + gap_width)) ** 2) / 0.0025))
+        support = np.exp(-(((yy - 0.55) ** 2) / 0.04))
+        return np.clip((left_band + right_band) * support, 0.0, 1.0).astype(np.float32)
+
+    def _support_stability(self) -> float:
+        base = 1.0 - 0.45 * self.disturbance - 0.10 * max(0.0, self.opening - self.dynamics.desired_opening)
+        if self._current_support_mode() == self.dynamics.preferred_mode:
+            base += 0.08
+        base -= self.support_stability_penalty
+        return float(np.clip(base, 0.0, 1.0))
+
+    def _support_stability_map(self) -> np.ndarray:
+        return np.full((32, 32), self._support_stability(), dtype=np.float32)
+
+    def _reocclusion_target(self, persistence: np.ndarray) -> float:
+        current_mode = int(self._current_support_mode())
+        horizon_ratio = persistence[current_mode] / float(max(1, self.rollout_horizon))
+        return float(np.clip(1.0 - horizon_ratio + 0.35 * self.disturbance + self.reocclusion_bias, 0.0, 1.0))
+
+    def _phase_label(
+        self,
+        visibility: float,
+        corridor: np.ndarray,
+        persistence: np.ndarray,
+        disturbance_cost: float,
+    ) -> int:
+        support_mode = int(self._current_support_mode())
+        corridor_ready = bool(corridor[support_mode, self.target_template] > 0.5)
+        persistence_ratio = persistence[support_mode] / float(max(1, self.rollout_horizon))
+        opening_ready = self.opening >= (0.75 * self.dynamics.desired_opening)
+        retrieve_ready = (
+            corridor_ready
+            and visibility >= self.dynamics.retrieve_visibility_threshold
+            and self.actor_progress >= 0.55
+        )
+        recovering = disturbance_cost >= 0.55 or (opening_ready and persistence_ratio < 0.35)
+        if retrieve_ready:
+            return 3
+        if recovering:
+            return 4
+        if opening_ready and persistence_ratio >= 0.6:
+            return 2
+        if self.opening < self.dynamics.desired_opening or visibility < self.dynamics.retrieve_visibility_threshold:
+            return 1
+        return 0
+
+    def _subgoal_progress(
+        self,
+        visibility: float,
+        corridor: np.ndarray,
+        persistence: np.ndarray,
+    ) -> float:
+        support_mode = int(self._current_support_mode())
+        corridor_mass = float(corridor[support_mode].mean())
+        persistence_ratio = float(persistence[support_mode] / float(max(1, self.rollout_horizon)))
+        return float(
+            np.clip(
+                0.35 * self.opening
+                + 0.25 * visibility
+                + 0.20 * corridor_mass
+                + 0.20 * persistence_ratio,
+                0.0,
+                1.0,
+            )
+        )
+
+    def _grasp_affordance_map(
+        self,
+        belief_map: np.ndarray,
+        visibility_map: np.ndarray,
+        clearance_map: np.ndarray,
+    ) -> np.ndarray:
+        combined = belief_map * visibility_map * clearance_map.mean(axis=0)
+        return np.clip(combined * (1.0 - 0.35 * self.disturbance), 0.0, 1.0).astype(np.float32)
+
+    def get_privileged_state(self) -> dict[str, Any]:
+        support_mode = int(self._current_support_mode())
+        corridor = np.stack(
+            [self._corridor_for_mode(mode) for mode in SupportMode],
+            axis=0,
+        )
+        persistence = np.asarray([self._persistence_for_mode(mode) for mode in SupportMode], dtype=np.float32)
+        visibility = self._visibility()
+        disturbance_cost = float(np.clip(self.disturbance + 0.08 * max(0.0, self.opening - self.dynamics.desired_opening), 0.0, 1.0))
+        belief_map = self._belief_map(visibility)
+        visibility_map = self._visibility_map(visibility)
+        clearance_map = self._clearance_map(visibility)
+        occluder_contact_map = self._occluder_contact_map()
+        support_stability = self._support_stability()
+        support_stability_map = self._support_stability_map()
+        reocclusion_target = self._reocclusion_target(persistence)
+        reocclusion_map = np.full((32, 32), reocclusion_target, dtype=np.float32)
+        grasp_affordance_map = self._grasp_affordance_map(belief_map, visibility_map, clearance_map)
+        task_metrics: dict[str, float] = {}
+        if self.proxy_name == FOLIAGE_PROXY.name:
+            task_metrics = {
+                "gap_width": float(np.clip(0.03 + 0.16 * self.opening, 0.03, 0.24)),
+                "damage_proxy": disturbance_cost,
+                "release_collapse_rate": reocclusion_target,
+                "target_visibility_confidence": visibility,
+            }
+        elif self.proxy_name == BAG_PROXY.name:
+            task_metrics = {
+                "mouth_aperture": float(self.opening),
+                "hold_quality": support_stability,
+                "rim_slip_risk": reocclusion_target,
+                "insertable_actor_corridor": float(corridor[support_mode, self.target_template]),
+            }
+        elif self.proxy_name == CLOTH_PROXY.name:
+            task_metrics = {
+                "layer_separation_quality": float(np.clip(self.opening * (1.0 - 0.20 * self.disturbance), 0.0, 1.0)),
+                "fold_preservation": float(np.clip(1.0 - disturbance_cost, 0.0, 1.0)),
+                "insertion_corridor": float(corridor[support_mode, self.target_template]),
+                "top_layer_stability": support_stability,
+                "lift_too_much_risk": float(np.clip(max(0.0, self.opening - self.dynamics.desired_opening), 0.0, 1.0)),
+            }
+        phase_label = self._phase_label(
+            visibility=visibility,
+            corridor=corridor,
+            persistence=persistence,
+            disturbance_cost=disturbance_cost,
+        )
+        subgoal_progress = self._subgoal_progress(
+            visibility=visibility,
+            corridor=corridor,
+            persistence=persistence,
+        )
+        return {
+            "support_mode": support_mode,
+            "corridor_feasible": corridor,
+            "persistence_horizon": persistence,
+            "disturbance_cost": disturbance_cost,
+            "belief_map": belief_map,
+            "visibility_map": visibility_map,
+            "clearance_map": clearance_map,
+            "occluder_contact_map": occluder_contact_map,
+            "grasp_affordance_map": grasp_affordance_map,
+            "support_stability": support_stability,
+            "support_stability_map": support_stability_map,
+            "reocclusion_target": reocclusion_target,
+            "reocclusion_map": reocclusion_map,
+            "visibility": visibility,
+            "retrieval_success": bool(self.retrieved),
+            "target_template": self.target_template,
+            "phase_label": int(phase_label),
+            "subgoal_progress": float(subgoal_progress),
+            "task_name": self.task_name,
+            "task_id": self.task_id,
+            "stress_slice": self.stress_slice,
+            "difficulty_bin": self.difficulty_bin,
+            "episode_metadata": self.episode_metadata(),
+            **task_metrics,
+        }
+
+    def render_state(self, privileged_state: dict[str, Any] | None = None) -> dict[str, Any]:
+        return {
+            "opening": float(self.opening),
+            "disturbance": float(self.disturbance),
+            "target_center": float(self.target_center),
+            "target_depth": float(self.target_depth),
+            "target_radius": float(self.target_radius),
+            "texture_phase": float(self.texture_phase),
+            "texture_scale": float(self.texture_scale),
+            "view_bias": float(self.view_bias),
+            "target_intensity": float(self.target_intensity),
+            "step_fraction": float(self.step_count / max(1, self.max_steps)),
+        }
+
+    def _proprio(self, privileged_state: dict[str, Any]) -> np.ndarray:
+        features = np.zeros((32,), dtype=np.float32)
+        step_fraction = self.step_count / float(max(1, self.max_steps))
+        features[0] = step_fraction
+        features[1] = np.sin(np.pi * step_fraction)
+        features[2] = np.cos(np.pi * step_fraction)
+        return features
+
+    def get_observation(self, privileged_state: dict[str, Any] | None = None) -> dict[str, Any]:
+        privileged_state = privileged_state or self.get_privileged_state()
+        render_state = self.render_state(privileged_state)
+        images = render_views_from_state(
+            proxy_name=self.proxy_name,
+            render_state=render_state,
+            resolution=self.resolution,
+            num_templates=self.num_templates,
+            include_depth=True,
+        )
+        camera_intrinsics, camera_extrinsics = default_camera_matrices(
+            pose_jitter=self.camera_pose_jitter,
+            focal_jitter=self.focal_jitter,
+            lateral_skew=self.lateral_skew,
+        )
+        return {
+            "images": np.stack([images[camera] for camera in self.camera_names], axis=0),
+            "depths": np.stack([images[f"{camera}_depth"] for camera in self.camera_names], axis=0)[:, None, :, :],
+            "depth_valid": np.stack([images[f"{camera}_depth_valid"] for camera in self.camera_names], axis=0)[:, None, :, :],
+            "proprio": self._proprio(privileged_state),
+            "text": PROXY_GOALS[self.proxy_name],
+            "task_name": self.task_name,
+            "task_id": self.task_id,
+            "stress_slice": self.stress_slice,
+            "difficulty_bin": self.difficulty_bin,
+            "episode_metadata": self.episode_metadata(),
+            "camera_names": self.camera_names,
+            "camera_intrinsics": camera_intrinsics,
+            "camera_extrinsics": camera_extrinsics,
+            "camera_valid_mask": np.ones((len(self.camera_names),), dtype=np.float32),
+        }
+
+    def teacher_action(self) -> np.ndarray:
+        privileged_state = self.get_privileged_state()
+        preferred_mode = self.dynamics.preferred_mode
+        if self.opening < self.dynamics.desired_opening:
+            chosen_mode = SupportMode.HOLD
+            open_cmd = 0.95
+        elif privileged_state["persistence_horizon"][preferred_mode] >= 2.0:
+            chosen_mode = preferred_mode
+            open_cmd = 0.12
+        else:
+            chosen_mode = SupportMode.HOLD
+            open_cmd = 0.30
+
+        corridor = privileged_state["corridor_feasible"][int(chosen_mode)]
+        actor_ready = bool(corridor[self.target_template] > 0.5)
+        retrieve = (
+            actor_ready
+            and privileged_state["visibility"] >= self.dynamics.retrieve_visibility_threshold
+            and self.actor_progress >= 0.55
+        )
+        action = np.zeros((14,), dtype=np.float32)
+        action[0] = np.float32(open_cmd)
+        action[1] = np.float32(1.0 if chosen_mode == SupportMode.TRANSFER else -1.0)
+        action[2] = np.float32(1.0 if chosen_mode == SupportMode.PASSIVE else -1.0)
+        action[6] = np.float32(1.0 if chosen_mode == SupportMode.HOLD else -1.0)
+        action[7] = np.float32(self._normalized_template(self.target_template))
+        action[8] = np.float32(1.0 if actor_ready else 0.2)
+        action[13] = np.float32(1.0 if retrieve else -1.0)
+        return action
+
+    def _set_mode_bits(self, action: np.ndarray, mode: SupportMode) -> None:
+        action[1] = np.float32(1.0 if mode == SupportMode.TRANSFER else -1.0)
+        action[2] = np.float32(1.0 if mode == SupportMode.PASSIVE else -1.0)
+        action[6] = np.float32(1.0 if mode == SupportMode.HOLD else -1.0)
+
+    def macro_action_chunk(self, macro_name: str, chunk_horizon: int = 8) -> np.ndarray:
+        preferred_mode = self.dynamics.preferred_mode
+        hold_mode = SupportMode.HOLD
+        passive_mode = SupportMode.PASSIVE
+        target_index = self.target_template
+        left_index = max(0, target_index - 4)
+        right_index = min(self.num_templates - 1, target_index + 4)
+        wrong_index = 0 if target_index > (self.num_templates // 2) else self.num_templates - 1
+
+        chunk = np.zeros((chunk_horizon, 14), dtype=np.float32)
+        for step_idx in range(chunk_horizon):
+            action = self.teacher_action()
+            action[13] = np.float32(-1.0)
+            action[8] = np.float32(0.2)
+            self._set_mode_bits(action, preferred_mode)
+
+            if macro_name in {"widen_gap", "widen_mouth", "lift_edge", "separate_layer"}:
+                self._set_mode_bits(action, hold_mode)
+                action[0] = np.float32(0.95)
+            elif macro_name in {"maintain_gap", "maintain_mouth", "maintain_lift", "stabilize_fold", "pin_canopy"}:
+                self._set_mode_bits(action, preferred_mode)
+                action[0] = np.float32(0.12)
+            elif macro_name in {"sweep_left", "pin_left_rim"}:
+                self._set_mode_bits(action, hold_mode)
+                action[0] = np.float32(0.75)
+                action[7] = np.float32(self._normalized_template(left_index))
+            elif macro_name in {"sweep_right", "pin_right_rim"}:
+                self._set_mode_bits(action, hold_mode)
+                action[0] = np.float32(0.75)
+                action[7] = np.float32(self._normalized_template(right_index))
+            elif macro_name == "probe_inside":
+                self._set_mode_bits(action, preferred_mode)
+                action[0] = np.float32(0.10)
+                action[8] = np.float32(0.75)
+            elif macro_name == "insert_actor":
+                self._set_mode_bits(action, preferred_mode)
+                action[0] = np.float32(0.10)
+                action[8] = np.float32(1.0)
+            elif macro_name == "retrieve":
+                self._set_mode_bits(action, preferred_mode)
+                action[0] = np.float32(0.05)
+                action[8] = np.float32(1.0)
+                action[13] = np.float32(1.0)
+            elif macro_name == "premature_retrieve":
+                self._set_mode_bits(action, passive_mode)
+                action[0] = np.float32(-0.20)
+                action[8] = np.float32(1.0)
+                action[13] = np.float32(1.0)
+            elif macro_name in {"reveal_with_release", "foliage_immediate_reocclusion"}:
+                reveal_phase = step_idx < max(1, chunk_horizon // 2)
+                self._set_mode_bits(action, hold_mode if reveal_phase else passive_mode)
+                action[0] = np.float32(0.95 if reveal_phase else -0.35)
+                action[8] = np.float32(0.2)
+            elif macro_name in {"wrong_side_reveal", "wrong_edge_reveal", "wrong_layer_reveal"}:
+                self._set_mode_bits(action, hold_mode)
+                action[0] = np.float32(0.65)
+                action[7] = np.float32(self._normalized_template(wrong_index))
+            elif macro_name in {"over_disturbance", "cloth_lift_high"}:
+                self._set_mode_bits(action, passive_mode)
+                action[0] = np.float32(1.0)
+                action[8] = np.float32(1.0 if macro_name == "over_disturbance" else 0.2)
+            elif macro_name == "delayed_actor_entry":
+                self._set_mode_bits(action, preferred_mode)
+                action[0] = np.float32(0.10)
+                action[8] = np.float32(0.2 if step_idx < (chunk_horizon - 1) else 1.0)
+            elif macro_name in {"weak_corridor_insert", "bag_fabric_probe"}:
+                self._set_mode_bits(action, passive_mode)
+                action[0] = np.float32(0.02)
+                action[8] = np.float32(1.0)
+            else:
+                action = self.teacher_action()
+            chunk[step_idx] = np.clip(action, -1.0, 1.0)
+        return chunk
+
+    def baseline_action_chunk(self, baseline_name: str, chunk_horizon: int = 8) -> np.ndarray:
+        if baseline_name == "teacher":
+            chunk, _ = self.teacher_chunk_and_rollout(chunk_horizon=chunk_horizon, rollout_horizon=self.rollout_horizon)
+            return chunk
+        if baseline_name == "reveal_only":
+            return self.macro_action_chunk("widen_gap" if self.proxy_name == FOLIAGE_PROXY.name else ("widen_mouth" if self.proxy_name == BAG_PROXY.name else "lift_edge"), chunk_horizon=chunk_horizon)
+        if baseline_name == "retrieve_only":
+            return self.macro_action_chunk("premature_retrieve", chunk_horizon=chunk_horizon)
+        if baseline_name == "no_hold":
+            return self.macro_action_chunk("reveal_with_release", chunk_horizon=chunk_horizon)
+        if baseline_name == "random":
+            return self.rng.uniform(-1.0, 1.0, size=(chunk_horizon, 14)).astype(np.float32)
+        raise KeyError(f"Unknown baseline chunk: {baseline_name}")
+
+    def teacher_chunk_and_rollout(
+        self,
+        chunk_horizon: int = 8,
+        rollout_horizon: int | None = None,
+    ) -> tuple[np.ndarray, dict[str, np.ndarray]]:
+        rollout_horizon = rollout_horizon or self.rollout_horizon
+        snapshot = self.clone_state()
+        action_chunk: list[np.ndarray] = []
+        rollout_support_mode = []
+        rollout_corridor = []
+        rollout_persistence = []
+        rollout_disturbance = []
+        rollout_belief = []
+        rollout_visibility = []
+        rollout_clearance = []
+        rollout_support_stability = []
+        rollout_reocclusion = []
+        rollout_occluder_contact = []
+        rollout_grasp_affordance = []
+        rollout_phase = []
+        for step in range(chunk_horizon):
+            action = self.teacher_action()
+            action_chunk.append(action)
+            _, _, terminated, truncated, privileged_state = self.step(action)
+            if step < rollout_horizon:
+                rollout_support_mode.append(privileged_state["support_mode"])
+                rollout_corridor.append(privileged_state["corridor_feasible"])
+                rollout_persistence.append(privileged_state["persistence_horizon"])
+                rollout_disturbance.append(privileged_state["disturbance_cost"])
+                rollout_belief.append(privileged_state["belief_map"])
+                rollout_visibility.append(privileged_state["visibility_map"])
+                rollout_clearance.append(privileged_state["clearance_map"])
+                rollout_support_stability.append(privileged_state["support_stability"])
+                rollout_reocclusion.append(privileged_state["reocclusion_target"])
+                rollout_occluder_contact.append(privileged_state["occluder_contact_map"])
+                rollout_grasp_affordance.append(privileged_state["grasp_affordance_map"])
+                rollout_phase.append(int(privileged_state["phase_label"]))
+            if terminated or truncated:
+                break
+        while len(action_chunk) < chunk_horizon:
+            action_chunk.append(np.zeros((14,), dtype=np.float32))
+        while len(rollout_support_mode) < rollout_horizon:
+            current = self.get_privileged_state()
+            rollout_support_mode.append(int(self._current_support_mode()))
+            rollout_corridor.append(current["corridor_feasible"])
+            rollout_persistence.append(current["persistence_horizon"])
+            rollout_disturbance.append(current["disturbance_cost"])
+            rollout_belief.append(current["belief_map"])
+            rollout_visibility.append(current["visibility_map"])
+            rollout_clearance.append(current["clearance_map"])
+            rollout_support_stability.append(current["support_stability"])
+            rollout_reocclusion.append(current["reocclusion_target"])
+            rollout_occluder_contact.append(current["occluder_contact_map"])
+            rollout_grasp_affordance.append(current["grasp_affordance_map"])
+            rollout_phase.append(int(current["phase_label"]))
+        self.restore_state(snapshot)
+        return np.stack(action_chunk, axis=0).astype(np.float32), {
+            "rollout_support_mode": np.asarray(rollout_support_mode, dtype=np.int64),
+            "rollout_corridor_feasible": np.asarray(rollout_corridor, dtype=np.float32),
+            "rollout_persistence_horizon": np.asarray(rollout_persistence, dtype=np.float32),
+            "rollout_disturbance_cost": np.asarray(rollout_disturbance, dtype=np.float32),
+            "rollout_belief_map": np.asarray(rollout_belief, dtype=np.float32),
+            "rollout_visibility_map": np.asarray(rollout_visibility, dtype=np.float32),
+            "rollout_clearance_map": np.asarray(rollout_clearance, dtype=np.float32),
+            "rollout_support_stability": np.asarray(rollout_support_stability, dtype=np.float32),
+            "rollout_reocclusion_target": np.asarray(rollout_reocclusion, dtype=np.float32),
+            "rollout_occluder_contact_map": np.asarray(rollout_occluder_contact, dtype=np.float32),
+            "rollout_grasp_affordance_map": np.asarray(rollout_grasp_affordance, dtype=np.float32),
+            "rollout_phase": np.asarray(rollout_phase, dtype=np.int64),
+        }
+
+    def evaluate_action_chunk(
+        self,
+        action_chunk: np.ndarray,
+        rollout_horizon: int | None = None,
+    ) -> dict[str, np.ndarray | float]:
+        rollout_horizon = rollout_horizon or self.rollout_horizon
+        snapshot = self.clone_state()
+        rollout_support_mode: list[int] = []
+        rollout_corridor: list[np.ndarray] = []
+        rollout_persistence: list[np.ndarray] = []
+        rollout_disturbance: list[float] = []
+        rollout_belief: list[np.ndarray] = []
+        rollout_visibility: list[np.ndarray] = []
+        rollout_clearance: list[np.ndarray] = []
+        rollout_support_stability: list[float] = []
+        rollout_reocclusion: list[float] = []
+        rollout_occluder_contact: list[np.ndarray] = []
+        rollout_grasp_affordance: list[np.ndarray] = []
+        rollout_phase: list[int] = []
+        corridor_open_trace = [float(self.get_privileged_state()["corridor_feasible"][self._current_support_mode()].any())]
+        visibility_trace = [float(self.get_privileged_state()["visibility"])]
+        disturbance_trace = [float(self.get_privileged_state()["disturbance_cost"])]
+        support_trace = [float(self.get_privileged_state()["support_stability"])]
+        opening_trace = [float(self.opening)]
+        terminated = False
+        truncated = False
+        privileged_state = self.get_privileged_state()
+        for step, action in enumerate(np.asarray(action_chunk, dtype=np.float32)):
+            _, _, terminated, truncated, privileged_state = self.step(action)
+            if step < rollout_horizon:
+                rollout_support_mode.append(int(privileged_state["support_mode"]))
+                rollout_corridor.append(privileged_state["corridor_feasible"].astype(np.float32))
+                rollout_persistence.append(privileged_state["persistence_horizon"].astype(np.float32))
+                rollout_disturbance.append(float(privileged_state["disturbance_cost"]))
+                rollout_belief.append(privileged_state["belief_map"].astype(np.float32))
+                rollout_visibility.append(privileged_state["visibility_map"].astype(np.float32))
+                rollout_clearance.append(privileged_state["clearance_map"].astype(np.float32))
+                rollout_support_stability.append(float(privileged_state["support_stability"]))
+                rollout_reocclusion.append(float(privileged_state["reocclusion_target"]))
+                rollout_occluder_contact.append(privileged_state["occluder_contact_map"].astype(np.float32))
+                rollout_grasp_affordance.append(privileged_state["grasp_affordance_map"].astype(np.float32))
+                rollout_phase.append(int(privileged_state["phase_label"]))
+            corridor_open_trace.append(float(privileged_state["corridor_feasible"][privileged_state["support_mode"]].any()))
+            visibility_trace.append(float(privileged_state["visibility"]))
+            disturbance_trace.append(float(privileged_state["disturbance_cost"]))
+            support_trace.append(float(privileged_state["support_stability"]))
+            opening_trace.append(float(self.opening))
+            if terminated or truncated:
+                break
+        while len(rollout_support_mode) < rollout_horizon:
+            current = self.get_privileged_state()
+            rollout_support_mode.append(int(current["support_mode"]))
+            rollout_corridor.append(current["corridor_feasible"].astype(np.float32))
+            rollout_persistence.append(current["persistence_horizon"].astype(np.float32))
+            rollout_disturbance.append(float(current["disturbance_cost"]))
+            rollout_belief.append(current["belief_map"].astype(np.float32))
+            rollout_visibility.append(current["visibility_map"].astype(np.float32))
+            rollout_clearance.append(current["clearance_map"].astype(np.float32))
+            rollout_support_stability.append(float(current["support_stability"]))
+            rollout_reocclusion.append(float(current["reocclusion_target"]))
+            rollout_occluder_contact.append(current["occluder_contact_map"].astype(np.float32))
+            rollout_grasp_affordance.append(current["grasp_affordance_map"].astype(np.float32))
+            rollout_phase.append(int(current["phase_label"]))
+        final_state = self.get_privileged_state()
+        corridor_curve = np.asarray(corridor_open_trace, dtype=np.float32)
+        visibility_curve = np.asarray(visibility_trace, dtype=np.float32)
+        disturbance_curve = np.asarray(disturbance_trace, dtype=np.float32)
+        support_curve = np.asarray(support_trace, dtype=np.float32)
+        opening_curve = np.asarray(opening_trace, dtype=np.float32)
+        reocclusion = float(
+            np.logical_and(
+                corridor_curve[:-1] > 0.5,
+                corridor_curve[1:] <= 0.5,
+            ).mean()
+        ) if len(corridor_open_trace) > 1 else 0.0
+        result: dict[str, np.ndarray | float] = {
+            "rollout_support_mode": np.asarray(rollout_support_mode, dtype=np.int64),
+            "rollout_corridor_feasible": np.asarray(rollout_corridor, dtype=np.float32),
+            "rollout_persistence_horizon": np.asarray(rollout_persistence, dtype=np.float32),
+            "rollout_disturbance_cost": np.asarray(rollout_disturbance, dtype=np.float32),
+            "rollout_belief_map": np.asarray(rollout_belief, dtype=np.float32),
+            "rollout_visibility_map": np.asarray(rollout_visibility, dtype=np.float32),
+            "rollout_clearance_map": np.asarray(rollout_clearance, dtype=np.float32),
+            "rollout_support_stability": np.asarray(rollout_support_stability, dtype=np.float32),
+            "rollout_reocclusion_target": np.asarray(rollout_reocclusion, dtype=np.float32),
+            "rollout_occluder_contact_map": np.asarray(rollout_occluder_contact, dtype=np.float32),
+            "rollout_grasp_affordance_map": np.asarray(rollout_grasp_affordance, dtype=np.float32),
+            "rollout_phase": np.asarray(rollout_phase, dtype=np.int64),
+            "retrieval_success": float(final_state["retrieval_success"]),
+            "final_disturbance_cost": float(final_state["disturbance_cost"]),
+            "reocclusion_rate": reocclusion,
+            "visibility_integral": float(np.sum(visibility_curve)),
+            "actor_feasibility_auc": float(corridor_curve.mean()),
+            "reveal_achieved": float(visibility_curve.max() >= self.dynamics.retrieve_visibility_threshold),
+            "hold_persistence": float(corridor_curve.mean()),
+            "support_stability_auc": float(support_curve.mean()),
+            "disturbance_auc": float(disturbance_curve.mean()),
+            "opening_peak": float(opening_curve.max()),
+        }
+        if self.proxy_name == FOLIAGE_PROXY.name:
+            result["candidate_gap_width"] = float(final_state.get("gap_width", opening_curve.max()))
+            result["candidate_damage_proxy"] = float(final_state.get("damage_proxy", final_state["disturbance_cost"]))
+        elif self.proxy_name == BAG_PROXY.name:
+            result["candidate_mouth_aperture"] = float(final_state.get("mouth_aperture", opening_curve.max()))
+            result["candidate_hold_quality"] = float(final_state.get("hold_quality", support_curve.mean()))
+            result["candidate_rim_slip_risk"] = float(final_state.get("rim_slip_risk", reocclusion))
+        elif self.proxy_name == CLOTH_PROXY.name:
+            result["candidate_fold_preservation"] = float(final_state.get("fold_preservation", 1.0 - final_state["disturbance_cost"]))
+            result["candidate_layer_separation_quality"] = float(final_state.get("layer_separation_quality", opening_curve.max()))
+            result["candidate_lift_too_much_risk"] = float(final_state.get("lift_too_much_risk", max(0.0, opening_curve.max() - self.dynamics.desired_opening)))
+            result["candidate_top_layer_stability"] = float(final_state.get("top_layer_stability", support_curve.mean()))
+        self.restore_state(snapshot)
+        return result
+
+    def candidate_outcome_utility(self, outcome: dict[str, np.ndarray | float]) -> float:
+        retrieval_success = float(outcome["retrieval_success"])
+        disturbance = float(outcome["final_disturbance_cost"])
+        reocclusion = float(outcome["reocclusion_rate"])
+        utility = retrieval_success - disturbance - reocclusion
+        if self.proxy_name == CLOTH_PROXY.name:
+            # Cloth success tracks layer separation more than strict fold/disturbance minimization.
+            # Keep a lift-risk penalty, but stop over-penalizing the slightly aggressive actions
+            # that actually create an insertable corridor on the proxy.
+            layer_separation = float(outcome.get("candidate_layer_separation_quality", outcome.get("opening_peak", 0.0)))
+            fold_preservation = float(outcome.get("candidate_fold_preservation", max(0.0, 1.0 - disturbance)))
+            lift_risk = float(outcome.get("candidate_lift_too_much_risk", 0.0))
+            utility = (
+                retrieval_success
+                + 0.80 * layer_separation
+                + 0.20 * fold_preservation
+                - 0.20 * disturbance
+                - 0.20 * reocclusion
+                - 0.35 * lift_risk
+            )
+        return float(utility)
+
+    def sample_candidate_action_chunks(
+        self,
+        teacher_chunk: np.ndarray,
+        num_candidates: int = 4,
+        rollout_horizon: int | None = None,
+    ) -> tuple[np.ndarray, dict[str, np.ndarray]]:
+        rollout_horizon = rollout_horizon or self.rollout_horizon
+        teacher_chunk = np.asarray(teacher_chunk, dtype=np.float32)
+        candidates = [teacher_chunk.astype(np.float32)]
+        outcomes = [self.evaluate_action_chunk(teacher_chunk, rollout_horizon=rollout_horizon)]
+        candidate_macro_ids = [0]
+        candidate_is_hard_negative = [0.0]
+        candidate_macro_names = ["teacher"]
+        candidate_negative_families = ["teacher"]
+        if self.proxy_name == FOLIAGE_PROXY.name:
+            semantic_specs = [
+                ("pin_canopy", "positive"),
+                ("maintain_gap", "positive"),
+                ("premature_retrieve", "premature_retrieve"),
+                ("reveal_with_release", "reveal_with_release"),
+                ("wrong_side_reveal", "wrong_side_reveal"),
+                ("foliage_immediate_reocclusion", "immediate_reocclusion"),
+                ("over_disturbance", "over_disturbance"),
+                ("weak_corridor_insert", "weak_corridor_insert"),
+                ("insert_actor", "positive"),
+                ("retrieve", "positive"),
+            ]
+        elif self.proxy_name == BAG_PROXY.name:
+            semantic_specs = [
+                ("widen_mouth", "positive"),
+                ("maintain_mouth", "positive"),
+                ("premature_retrieve", "premature_retrieve"),
+                ("reveal_with_release", "reveal_with_release"),
+                ("wrong_edge_reveal", "wrong_side_reveal"),
+                ("pin_left_rim", "one_rim_slip"),
+                ("bag_fabric_probe", "fabric_probe"),
+                ("weak_corridor_insert", "weak_corridor_insert"),
+                ("insert_actor", "positive"),
+                ("retrieve", "positive"),
+            ]
+        else:
+            semantic_specs = [
+                ("lift_edge", "positive"),
+                ("stabilize_fold", "positive"),
+                ("premature_retrieve", "premature_retrieve"),
+                ("reveal_with_release", "reveal_with_release"),
+                ("cloth_lift_high", "lift_too_high"),
+                ("wrong_layer_reveal", "wrong_layer_reveal"),
+                ("delayed_actor_entry", "delayed_actor_entry"),
+                ("weak_corridor_insert", "weak_corridor_insert"),
+                ("insert_actor", "positive"),
+                ("retrieve", "positive"),
+            ]
+
+        for spec_idx, (macro_name, family_name) in enumerate(semantic_specs[: max(0, num_candidates - 1)], start=1):
+            candidate = self.macro_action_chunk(macro_name, chunk_horizon=teacher_chunk.shape[0])
+            candidates.append(candidate.astype(np.float32))
+            outcomes.append(self.evaluate_action_chunk(candidate, rollout_horizon=rollout_horizon))
+            candidate_macro_ids.append(spec_idx)
+            candidate_macro_names.append(macro_name)
+            candidate_negative_families.append(family_name)
+            candidate_is_hard_negative.append(0.0 if family_name == "positive" else 1.0)
+
+        while len(candidates) < num_candidates:
+            random_chunk = self.rng.uniform(-1.0, 1.0, size=teacher_chunk.shape).astype(np.float32)
+            candidates.append(random_chunk)
+            outcomes.append(self.evaluate_action_chunk(random_chunk, rollout_horizon=rollout_horizon))
+            candidate_macro_ids.append(len(candidate_macro_ids))
+            candidate_macro_names.append("random")
+            candidate_negative_families.append("random")
+            candidate_is_hard_negative.append(1.0)
+        stacked_outcomes = {
+            "candidate_rollout_support_mode": np.stack([item["rollout_support_mode"] for item in outcomes], axis=0).astype(np.int64),
+            "candidate_rollout_phase": np.stack([item["rollout_phase"] for item in outcomes], axis=0).astype(np.int64),
+            "candidate_rollout_corridor_feasible": np.stack(
+                [item["rollout_corridor_feasible"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_persistence_horizon": np.stack(
+                [item["rollout_persistence_horizon"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_disturbance_cost": np.stack(
+                [item["rollout_disturbance_cost"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_belief_map": np.stack(
+                [item["rollout_belief_map"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_visibility_map": np.stack(
+                [item["rollout_visibility_map"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_clearance_map": np.stack(
+                [item["rollout_clearance_map"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_support_stability": np.stack(
+                [item["rollout_support_stability"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_reocclusion_target": np.stack(
+                [item["rollout_reocclusion_target"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_occluder_contact_map": np.stack(
+                [item["rollout_occluder_contact_map"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_rollout_grasp_affordance_map": np.stack(
+                [item["rollout_grasp_affordance_map"] for item in outcomes], axis=0
+            ).astype(np.float32),
+            "candidate_retrieval_success": np.asarray([item["retrieval_success"] for item in outcomes], dtype=np.float32),
+            "candidate_final_disturbance_cost": np.asarray(
+                [item["final_disturbance_cost"] for item in outcomes], dtype=np.float32
+            ),
+            "candidate_reocclusion_rate": np.asarray([item["reocclusion_rate"] for item in outcomes], dtype=np.float32),
+            "candidate_visibility_integral": np.asarray([item["visibility_integral"] for item in outcomes], dtype=np.float32),
+            "candidate_actor_feasibility_auc": np.asarray([item["actor_feasibility_auc"] for item in outcomes], dtype=np.float32),
+            "candidate_reveal_achieved": np.asarray([item["reveal_achieved"] for item in outcomes], dtype=np.float32),
+            "candidate_hold_persistence": np.asarray([item["hold_persistence"] for item in outcomes], dtype=np.float32),
+            "candidate_support_stability_auc": np.asarray([item["support_stability_auc"] for item in outcomes], dtype=np.float32),
+            "candidate_disturbance_auc": np.asarray([item["disturbance_auc"] for item in outcomes], dtype=np.float32),
+            "candidate_macro_ids": np.asarray(candidate_macro_ids, dtype=np.int64),
+            "candidate_is_hard_negative": np.asarray(candidate_is_hard_negative, dtype=np.float32),
+        }
+        stacked_outcomes["candidate_risk"] = np.clip(
+            stacked_outcomes["candidate_final_disturbance_cost"] + stacked_outcomes["candidate_reocclusion_rate"],
+            0.0,
+            1.0,
+        ).astype(np.float32)
+        stacked_outcomes["candidate_utility"] = np.asarray(
+            [self.candidate_outcome_utility(item) for item in outcomes],
+            dtype=np.float32,
+        )
+        stacked_outcomes["candidate_macro_names"] = candidate_macro_names
+        stacked_outcomes["candidate_negative_families"] = candidate_negative_families
+        if self.proxy_name == FOLIAGE_PROXY.name:
+            stacked_outcomes["candidate_gap_width"] = np.asarray([item["candidate_gap_width"] for item in outcomes], dtype=np.float32)
+            stacked_outcomes["candidate_damage_proxy"] = np.asarray([item["candidate_damage_proxy"] for item in outcomes], dtype=np.float32)
+        elif self.proxy_name == BAG_PROXY.name:
+            stacked_outcomes["candidate_mouth_aperture"] = np.asarray([item["candidate_mouth_aperture"] for item in outcomes], dtype=np.float32)
+            stacked_outcomes["candidate_hold_quality"] = np.asarray([item["candidate_hold_quality"] for item in outcomes], dtype=np.float32)
+            stacked_outcomes["candidate_rim_slip_risk"] = np.asarray([item["candidate_rim_slip_risk"] for item in outcomes], dtype=np.float32)
+        elif self.proxy_name == CLOTH_PROXY.name:
+            stacked_outcomes["candidate_fold_preservation"] = np.asarray([item["candidate_fold_preservation"] for item in outcomes], dtype=np.float32)
+            stacked_outcomes["candidate_layer_separation_quality"] = np.asarray([item["candidate_layer_separation_quality"] for item in outcomes], dtype=np.float32)
+            stacked_outcomes["candidate_lift_too_much_risk"] = np.asarray([item["candidate_lift_too_much_risk"] for item in outcomes], dtype=np.float32)
+        return np.stack(candidates, axis=0).astype(np.float32), stacked_outcomes
+
+    def step(self, action: np.ndarray) -> tuple[dict[str, Any], float, bool, bool, dict[str, Any]]:
+        action = np.asarray(action, dtype=np.float32)
+        mode = self._mode_from_action(action)
+        self.holding = mode == SupportMode.HOLD
+        self.transferred = mode == SupportMode.TRANSFER
+        open_cmd = float(np.clip(action[0], -1.0, 1.0))
+        actor_reach = float((np.tanh(float(action[8])) + 1.0) * 0.5)
+        retrieve_cmd = float((np.tanh(float(action[13])) + 1.0) * 0.5)
+        self.last_actor_template = int(
+            np.clip(
+                round(((float(np.clip(action[7], -1.0, 1.0)) + 1.0) * 0.5) * (self.num_templates - 1)),
+                0,
+                self.num_templates - 1,
+            )
+        )
+
+        support_bonus = {SupportMode.HOLD: 0.08, SupportMode.TRANSFER: 0.04, SupportMode.PASSIVE: 0.0}[mode]
+        closure = self.closure_scale * self._mode_decay(mode)
+        self.opening = float(
+            np.clip(
+                self.opening + 0.16 * open_cmd + support_bonus - closure - 0.05 * self.disturbance,
+                0.0,
+                1.0,
+            )
+        )
+        self.disturbance = float(
+            np.clip(
+                self.disturbance
+                + self.disturbance_gain_scale * self.dynamics.disturbance_gain * abs(open_cmd)
+                + 0.025 * actor_reach
+                + 0.05 * max(0.0, self.opening - self.dynamics.desired_opening)
+                + 0.03 * self.collateral_bias * actor_reach
+                - self.dynamics.settle_rate,
+                0.0,
+                1.0,
+            )
+        )
+
+        self.step_count += 1
+        privileged_state = self.get_privileged_state()
+        corridor = privileged_state["corridor_feasible"][privileged_state["support_mode"]]
+        if corridor[self.last_actor_template] > 0.5 and actor_reach >= 0.55:
+            persistence_ratio = privileged_state["persistence_horizon"][privileged_state["support_mode"]] / float(
+                max(1, self.rollout_horizon)
+            )
+            self.actor_progress = float(np.clip(self.actor_progress + 0.55 * persistence_ratio, 0.0, 1.0))
+            shock = 0.16 * max(0.0, 0.8 - persistence_ratio)
+            if shock > 0.0:
+                self.opening = float(np.clip(self.opening - shock, 0.0, 1.0))
+                privileged_state = self.get_privileged_state()
+                corridor = privileged_state["corridor_feasible"][privileged_state["support_mode"]]
+        else:
+            self.actor_progress = float(np.clip(self.actor_progress - 0.20, 0.0, 1.0))
+        success = bool(
+            retrieve_cmd >= 0.55
+            and self.actor_progress >= 0.80
+            and corridor[self.last_actor_template] > 0.5
+            and privileged_state["visibility"] >= self.dynamics.retrieve_visibility_threshold
+            and self.disturbance < 0.9
+        )
+        if success:
+            self.retrieved = True
+            privileged_state["retrieval_success"] = True
+
+        self.visibility_trace.append(float(privileged_state["visibility"]))
+        self.corridor_trace.append(float(corridor.any()))
+
+        reward = 1.0 if success else (0.08 * privileged_state["visibility"] - 0.03 * privileged_state["disturbance_cost"])
+        terminated = bool(self.retrieved)
+        truncated = bool(self.step_count >= self.max_steps)
+        return self.get_observation(privileged_state), float(reward), terminated, truncated, privileged_state
+
+
+def render_views_from_state(
+    proxy_name: str,
+    render_state: dict[str, Any],
+    resolution: int,
+    num_templates: int = 32,
+    include_depth: bool = False,
+) -> dict[str, np.ndarray]:
+    dynamics = PROXY_DYNAMICS[proxy_name]
+    opening = float(render_state["opening"])
+    disturbance = float(render_state["disturbance"])
+    target_center = float(render_state["target_center"])
+    target_depth = float(render_state["target_depth"])
+    target_radius = float(render_state["target_radius"])
+    texture_phase = float(render_state["texture_phase"])
+    texture_scale = float(render_state["texture_scale"])
+    view_bias = float(render_state["view_bias"])
+    target_intensity = float(render_state["target_intensity"])
+    step_fraction = float(render_state["step_fraction"])
+
+    height = width = resolution
+    base = np.ones((height, width, 3), dtype=np.float32)
+    base *= np.asarray(dynamics.palette, dtype=np.float32)
+
+    x = np.linspace(0.0, 1.0, width, dtype=np.float32)
+    y = np.linspace(0.0, 1.0, height, dtype=np.float32)
+    yy, xx = np.meshgrid(y, x, indexing="ij")
+    visibility = np.clip(
+        1.25 * opening - 0.68 * disturbance - 0.24 * target_depth + dynamics.visibility_bias,
+        0.0,
+        1.0,
+    )
+    target_y = 0.74 - 0.22 * target_depth
+    gap_width = np.clip(0.05 + 0.16 * opening - 0.08 * disturbance, 0.02, 0.24)
+    front_center = np.clip(target_center + 0.03 * view_bias, 0.06, 0.94)
+    left_center = np.clip(0.34 + 0.12 * (target_center - 0.5) - 0.05 * view_bias, 0.18, 0.52)
+    right_center = np.clip(0.66 + 0.18 * (target_center - 0.5) + 0.06 * view_bias, 0.42, 0.88)
+    surface_wave = 0.5 + 0.5 * np.sin((xx * (14.0 * texture_scale) + yy * 7.0) * np.pi + texture_phase)
+    weave_wave = 0.5 + 0.5 * np.cos((xx * 6.0 - yy * (10.0 + 2.0 * texture_scale)) * np.pi - 0.6 * texture_phase)
+    clutter = 0.65 * surface_wave + 0.35 * weave_wave
+    disturbance_map = disturbance * (
+        0.55 + 0.45 * np.sin((xx * 9.0 + yy * (12.0 + texture_scale)) * np.pi + 1.3 * texture_phase)
+    )
+    target_mask = ((xx - front_center) ** 2 + ((yy - target_y) / 1.2) ** 2) <= target_radius**2
+
+    front = base.copy()
+    front *= (0.82 + 0.24 * clutter[..., None]).astype(np.float32)
+    occluder_profile = np.abs(xx - front_center) / gap_width + 0.55 * np.abs(yy - (0.56 + 0.08 * view_bias))
+    gap_mask = occluder_profile <= (1.15 + 0.35 * opening)
+    front[gap_mask] = np.clip(front[gap_mask] + np.asarray([0.14, 0.16, 0.14], dtype=np.float32), 0.0, 1.0)
+    target_rgb = np.asarray([0.78, 0.74, 0.58], dtype=np.float32) * target_intensity
+    front[target_mask] = np.clip(
+        front[target_mask] * (1.0 - 0.45 * visibility) + target_rgb * (0.25 + 0.75 * visibility),
+        0.0,
+        1.0,
+    )
+    front[..., 2] = np.clip(front[..., 2] + 0.12 * disturbance_map + 0.04 * step_fraction, 0.0, 1.0)
+
+    wrist_left = np.full((height, width, 3), 0.12, dtype=np.float32)
+    wrist_left *= (0.8 + 0.18 * clutter[..., None]).astype(np.float32)
+    left_slit_width = np.clip(0.04 + 0.18 * opening - 0.10 * disturbance, 0.015, 0.22)
+    left_profile = ((xx - left_center) / left_slit_width) ** 2 + ((yy - 0.58) / (0.40 + 0.10 * opening)) ** 2
+    left_open = left_profile <= 1.0
+    wrist_left[left_open] = np.clip(wrist_left[left_open] + np.asarray([0.08, 0.22, 0.12], dtype=np.float32), 0.0, 1.0)
+    wrist_left[..., 0] = np.clip(wrist_left[..., 0] + 0.18 * disturbance_map, 0.0, 1.0)
+    wrist_left[target_mask] = np.clip(
+        wrist_left[target_mask] * (1.0 - 0.35 * visibility) + target_rgb * (0.18 + 0.52 * visibility),
+        0.0,
+        1.0,
+    )
+
+    wrist_right = np.full((height, width, 3), 0.08, dtype=np.float32)
+    wrist_right *= (0.78 + 0.22 * clutter[..., None]).astype(np.float32)
+    right_band = np.exp(-((xx - right_center) ** 2) / max(1e-4, (0.06 + gap_width) ** 2))
+    right_clear = np.exp(-((yy - (0.52 - 0.12 * target_depth)) ** 2) / max(1e-4, (0.12 + 0.18 * opening) ** 2))
+    wrist_right[..., 1] = np.clip(
+        wrist_right[..., 1] + 0.28 * visibility * right_band * right_clear - 0.10 * disturbance_map,
+        0.0,
+        1.0,
+    )
+    wrist_right[target_mask] = np.clip(
+        wrist_right[target_mask] * (1.0 - 0.40 * visibility) + target_rgb * (0.22 + 0.60 * visibility),
+        0.0,
+        1.0,
+    )
+    wrist_right[..., 2] = np.clip(wrist_right[..., 2] + 0.08 * step_fraction + 0.06 * right_band, 0.0, 1.0)
+    wrist_right = np.clip(wrist_right, 0.0, 1.0)
+
+    outputs = {
+        "front": (front * 255.0).astype(np.uint8),
+        "wrist_left": (wrist_left * 255.0).astype(np.uint8),
+        "wrist_right": (wrist_right * 255.0).astype(np.uint8),
+    }
+    if not include_depth:
+        return outputs
+
+    front_depth = np.clip(0.25 + 0.40 * target_depth + 0.15 * disturbance + 0.10 * (1.0 - visibility), 0.0, 1.0)
+    target_depth_map = np.clip(0.10 + 0.55 * target_depth, 0.0, 1.0)
+    occluder_depth = np.clip(0.30 + 0.20 * disturbance + 0.10 * (1.0 - opening), 0.0, 1.0)
+    front_depth_map = np.full((height, width), front_depth, dtype=np.float32)
+    front_depth_map[gap_mask] = np.minimum(front_depth_map[gap_mask], occluder_depth)
+    front_depth_map[target_mask] = np.minimum(front_depth_map[target_mask], target_depth_map)
+
+    wrist_left_depth = np.clip(0.35 + 0.25 * target_depth + 0.10 * disturbance, 0.0, 1.0)
+    wrist_left_depth_map = np.full((height, width), wrist_left_depth, dtype=np.float32)
+    wrist_left_depth_map[left_open] = np.minimum(wrist_left_depth_map[left_open], 0.22 + 0.25 * target_depth)
+    wrist_left_depth_map[target_mask] = np.minimum(wrist_left_depth_map[target_mask], target_depth_map)
+
+    wrist_right_depth = np.clip(0.35 + 0.20 * target_depth + 0.12 * disturbance, 0.0, 1.0)
+    wrist_right_depth_map = np.full((height, width), wrist_right_depth, dtype=np.float32)
+    right_focus = (right_band * right_clear) > 0.15
+    wrist_right_depth_map[right_focus] = np.minimum(wrist_right_depth_map[right_focus], 0.20 + 0.25 * target_depth)
+    wrist_right_depth_map[target_mask] = np.minimum(wrist_right_depth_map[target_mask], target_depth_map)
+
+    outputs.update(
+        {
+            "front_depth": front_depth_map.astype(np.float32),
+            "wrist_left_depth": wrist_left_depth_map.astype(np.float32),
+            "wrist_right_depth": wrist_right_depth_map.astype(np.float32),
+            "front_depth_valid": np.ones((height, width), dtype=np.float32),
+            "wrist_left_depth_valid": np.ones((height, width), dtype=np.float32),
+            "wrist_right_depth_valid": np.ones((height, width), dtype=np.float32),
+        }
+    )
+    return outputs

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/teachers.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass
+class TeacherAction:
+    revealer_action: np.ndarray
+    actor_action: np.ndarray
+
+
+def foliage_teacher_step(privileged_state: dict[str, Any]) -> TeacherAction:
+    target_cluster = privileged_state.get("lowest_cost_strip_direction", [0.0, 0.0, 1.0])
+    actor_ready = bool(privileged_state.get("corridor_exists", False))
+    revealer = np.asarray(target_cluster, dtype=np.float32)
+    actor = np.asarray(privileged_state.get("retrieve_direction", [0.0, 0.0, 0.0]), dtype=np.float32)
+    if not actor_ready:
+        actor = np.zeros_like(actor)
+    return TeacherAction(revealer_action=revealer, actor_action=actor)
+
+
+def bag_teacher_step(privileged_state: dict[str, Any]) -> TeacherAction:
+    contact_a = np.asarray(privileged_state.get("expand_contact_a", [1.0, 0.0, 0.0]), dtype=np.float32)
+    contact_b = np.asarray(privileged_state.get("expand_contact_b", [-1.0, 0.0, 0.0]), dtype=np.float32)
+    aperture_ready = float(privileged_state.get("aperture", 0.0)) >= float(privileged_state.get("aperture_threshold", 1.0))
+    actor = np.asarray(privileged_state.get("retrieve_direction", [0.0, 0.0, 0.0]), dtype=np.float32)
+    if not aperture_ready:
+        actor = np.zeros_like(actor)
+    return TeacherAction(revealer_action=np.concatenate([contact_a, contact_b]), actor_action=actor)
+
+
+def cloth_teacher_step(privileged_state: dict[str, Any]) -> TeacherAction:
+    lift = np.asarray(privileged_state.get("minimal_lift_direction", [0.0, 0.0, 1.0]), dtype=np.float32)
+    actor_ready = bool(privileged_state.get("target_exposed", False))
+    actor = np.asarray(privileged_state.get("retrieve_direction", [0.0, 0.0, 0.0]), dtype=np.float32)
+    if not actor_ready:
+        actor = np.zeros_like(actor)
+    return TeacherAction(revealer_action=lift, actor_action=actor)

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/base.yaml

@@ -0,0 +1,20 @@
+defaults:
+  - model: backbone_only
+  - data: rlbench_3cam
+  - _self_
+
+trainer:
+  policy_type: backbone_only
+  use_bf16: true
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: true
+
+optim:
+  lr: 1.0e-4
+  weight_decay: 1.0e-4
+
+runtime:
+  batch_size: 8
+  num_workers: 4
+  seed: 0

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/model/backbone_only.yaml

@@ -0,0 +1,26 @@
+policy:
+  backbone:
+    model_name: openai/clip-vit-base-patch32
+    hidden_dim: 512
+    max_text_tokens: 32
+    freeze_backbone: true
+    gradient_checkpointing: true
+    use_dummy_backbone: false
+  fusion:
+    hidden_dim: 512
+    num_cameras: 3
+    num_layers: 4
+    num_heads: 8
+    ff_dim: 2048
+    dropout: 0.1
+    proprio_dim: 32
+    proprio_tokens: 1
+  decoder:
+    hidden_dim: 512
+    num_heads: 8
+    num_layers: 4
+    ff_dim: 2048
+    dropout: 0.1
+    chunk_size: 8
+    action_dim: 14
+    num_candidates: 8

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_adapter_wrapped_clip_base_fast.yaml

@@ -0,0 +1,92 @@
+experiment_name: proxy_adapter_wrapped_clip_base_fast_seed17
+output_dir: /workspace/workspace/outputs/adapter_proxy
+device: cuda
+seed: 17
+init_checkpoint: /workspace/workspace/VLAarchtests2/VLAarchtests/artifacts/outputs/r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_seed17/checkpoint_best.pt
+init_strict: false
+
+data:
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  resolution: 224
+  dataset_version: reveal_proxy_v6_rgbd_elastic_state_phase_fast
+  train_episodes_per_proxy: 12
+  val_episodes_per_proxy: 4
+  train_dataset_path: /workspace/workspace/data/reveal_proxy/proxy_train_clip224_v6_rgbd_stage3_phase_fast.pt
+  val_dataset_path: /workspace/workspace/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage3_phase_fast.pt
+  rebuild_dataset: false
+  chunk_horizon: 8
+  rollout_horizon: 5
+  history_steps: 6
+  planner_candidates: 8
+  seed: 17
+
+optim:
+  epochs: 2
+  batch_size: 4
+  num_workers: 8
+  lr: 0.0001
+  weight_decay: 0.0001
+
+trainer:
+  policy_type: adapter_wrapped
+  training_regime: adapter_train_frozen_trunk
+  eval_mode: adapter_active
+  adapter_mode: adapter_active
+  adapter_use_transition_model: false
+  adapter_use_task_conditioning: true
+  use_bf16: true
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: false
+  plan_during_train: false
+  plan_during_eval: false
+  support_mode_conditioning: true
+  planner_mode: off
+  use_depth: true
+  use_world_model: false
+  use_role_tokens: true
+  compute_equivariance_probe: false
+  trainable_parameter_prefixes:
+    - adapter.state_head
+    - adapter.proposal_prior
+    - adapter.planner
+
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 512, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: false}
+  fusion: {hidden_dim: 512, num_cameras: 3, num_layers: 4, num_heads: 8, ff_dim: 2048, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 512, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 8, max_history_steps: 8, reveal_cache_steps: 4, reveal_cache_decay: 0.7}
+  decoder: {hidden_dim: 512, num_heads: 8, num_layers: 4, ff_dim: 2048, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 7, planner_top_k: 4, proposal_delta_scale: 0.2, proposal_slot_scale: 0.05}
+  reveal_head: {hidden_dim: 512, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 8, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, num_tasks: 4}
+  world_model: {hidden_dim: 512, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 8, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2, rollout_mode: compact_rollout, num_tasks: 4, lightweight_field_size: 4}
+  planner: {hidden_dim: 512, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 8, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4, adapter_confidence_threshold: 0.45}
+
+loss_weights:
+  action: 1.0
+  phase: 0.08
+  arm_role: 0.08
+  support_mode: 0.08
+  corridor: 0.12
+  persistence: 0.06
+  disturbance: 0.06
+  world_model: 0.0
+  transition: 0.0
+  belief: 0.05
+  visibility: 0.05
+  clearance: 0.06
+  support_stability: 0.06
+  reocclusion: 0.06
+  occluder_contact: 0.05
+  grasp_affordance: 0.05
+  planner_success: 0.15
+  planner_risk: 0.08
+  planner_ranking: 0.15
+  proposal_reconstruction: 0.08
+  proposal_success: 0.1
+  proposal_ranking: 0.12
+  proposal_mode: 0.08
+  proposal_diversity: 0.05
+  role_swap_consistency: 0.0
+  task_metrics: 0.06
+  gate: 0.05
+  distillation: 0.05
+  calibration: 0.02

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_adapter_wrapped_clip_rank_only_rebuild128.yaml

@@ -0,0 +1,91 @@
+experiment_name: proxy_adapter_wrapped_clip_rank_only_rebuild128_seed17
+output_dir: /workspace/workspace/outputs/adapter_proxy
+device: cuda
+seed: 17
+init_checkpoint: /workspace/workspace/VLAarchtests2/VLAarchtests/artifacts/outputs/r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_seed17/checkpoint_best.pt
+init_strict: false
+
+data:
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  resolution: 224
+  dataset_version: reveal_proxy_v6_rgbd_elastic_state_phase
+  train_episodes_per_proxy: 128
+  val_episodes_per_proxy: 32
+  train_dataset_path: /workspace/workspace/data/reveal_proxy/proxy_train_clip224_v6_rgbd_stage3_phase_rebuild128_seed17.pt
+  val_dataset_path: /workspace/workspace/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage3_phase_rebuild128_seed17.pt
+  rebuild_dataset: true
+  chunk_horizon: 8
+  rollout_horizon: 5
+  history_steps: 6
+  planner_candidates: 8
+  seed: 17
+
+optim:
+  epochs: 4
+  batch_size: 8
+  num_workers: 32
+  lr: 0.00005
+  weight_decay: 0.0001
+
+trainer:
+  policy_type: adapter_wrapped
+  training_regime: proxy_rank_only
+  eval_mode: adapter_active
+  adapter_mode: adapter_active
+  adapter_use_transition_model: false
+  adapter_use_task_conditioning: true
+  use_bf16: true
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: false
+  plan_during_train: false
+  plan_during_eval: false
+  support_mode_conditioning: true
+  planner_mode: off
+  use_depth: true
+  use_world_model: false
+  use_role_tokens: true
+  compute_equivariance_probe: false
+  trainable_parameter_prefixes:
+    - adapter.proposal_prior
+    - adapter.planner
+
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 512, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: false}
+  fusion: {hidden_dim: 512, num_cameras: 3, num_layers: 4, num_heads: 8, ff_dim: 2048, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 512, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 8, max_history_steps: 8}
+  decoder: {hidden_dim: 512, num_heads: 8, num_layers: 4, ff_dim: 2048, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 7, planner_top_k: 4, proposal_delta_scale: 0.2, proposal_slot_scale: 0.05}
+  reveal_head: {hidden_dim: 512, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 8, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, num_tasks: 4}
+  world_model: {hidden_dim: 512, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 8, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2, rollout_mode: compact_rollout, num_tasks: 4, lightweight_field_size: 4}
+  planner: {hidden_dim: 512, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 8, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4, adapter_confidence_threshold: 0.55}
+
+loss_weights:
+  action: 0.5
+  phase: 0.0
+  arm_role: 0.0
+  support_mode: 0.0
+  corridor: 0.0
+  persistence: 0.0
+  disturbance: 0.0
+  world_model: 0.0
+  transition: 0.0
+  belief: 0.0
+  visibility: 0.0
+  clearance: 0.0
+  support_stability: 0.0
+  reocclusion: 0.0
+  occluder_contact: 0.0
+  grasp_affordance: 0.0
+  planner_success: 0.0
+  planner_risk: 0.0
+  planner_ranking: 0.2
+  proposal_reconstruction: 0.0
+  proposal_success: 0.1
+  proposal_ranking: 0.2
+  proposal_mode: 0.1
+  proposal_diversity: 0.02
+  role_swap_consistency: 0.0
+  task_metrics: 0.0
+  gate: 0.0
+  distillation: 0.05
+  calibration: 0.0

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_backbone_only_clip.yaml

@@ -0,0 +1,97 @@
+experiment_name: proxy_backbone_only_clip
+output_dir: /workspace/outputs/reveal_runs
+device: cuda
+seed: 7
+
+data:
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  resolution: 224
+  train_episodes_per_proxy: 48
+  val_episodes_per_proxy: 16
+  train_dataset_path: /workspace/data/reveal_proxy/proxy_train_clip224_v4_noleak_counterfactual.pt
+  val_dataset_path: /workspace/data/reveal_proxy/proxy_val_clip224_v4_noleak_counterfactual.pt
+  rebuild_dataset: true
+  chunk_horizon: 8
+  rollout_horizon: 5
+  history_steps: 2
+  planner_candidates: 4
+  seed: 7
+
+optim:
+  epochs: 4
+  batch_size: 2
+  num_workers: 0
+  lr: 0.0003
+  weight_decay: 0.0001
+
+trainer:
+  policy_type: backbone_only
+  use_bf16: true
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: false
+  plan_during_train: false
+  plan_during_eval: false
+  support_mode_conditioning: true
+
+policy:
+  backbone:
+    model_name: openai/clip-vit-base-patch32
+    hidden_dim: 512
+    max_text_tokens: 32
+    freeze_backbone: true
+    gradient_checkpointing: false
+    use_dummy_backbone: false
+  fusion:
+    hidden_dim: 512
+    num_cameras: 3
+    num_layers: 4
+    num_heads: 8
+    ff_dim: 2048
+    dropout: 0.1
+    proprio_dim: 32
+    proprio_tokens: 1
+  memory:
+    hidden_dim: 512
+    history_steps: 2
+    num_layers: 1
+    dropout: 0.1
+  decoder:
+    hidden_dim: 512
+    num_heads: 8
+    num_layers: 4
+    ff_dim: 2048
+    dropout: 0.1
+    chunk_size: 8
+    action_dim: 14
+    num_candidates: 8
+  reveal_head:
+    hidden_dim: 512
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 5
+    belief_map_size: 32
+    predict_belief_map: true
+  world_model:
+    hidden_dim: 512
+    action_dim: 14
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 5
+  planner:
+    hidden_dim: 512
+    num_candidates: 8
+    action_dim: 14
+    utility_margin: 0.1
+
+loss_weights:
+  action: 1.0
+  support_mode: 0.1
+  corridor: 0.1
+  persistence: 0.05
+  disturbance: 0.05
+  world_model: 0.1
+  belief: 0.05
+  planner_success: 0.0
+  planner_risk: 0.0
+  planner_ranking: 0.0

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_backbone_only_smoke.yaml

@@ -0,0 +1,100 @@
+experiment_name: proxy_backbone_only_smoke
+output_dir: /workspace/outputs/smoke
+device: cuda
+seed: 11
+
+data:
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  resolution: 64
+  train_episodes_per_proxy: 6
+  val_episodes_per_proxy: 2
+  train_dataset_path: /workspace/data/reveal_proxy/proxy_train_smoke_v4.pt
+  val_dataset_path: /workspace/data/reveal_proxy/proxy_val_smoke_v4.pt
+  rebuild_dataset: true
+  chunk_horizon: 4
+  rollout_horizon: 3
+  history_steps: 2
+  planner_candidates: 4
+  seed: 11
+
+optim:
+  epochs: 2
+  batch_size: 8
+  num_workers: 0
+  lr: 0.001
+  weight_decay: 0.0001
+
+trainer:
+  policy_type: backbone_only
+  use_bf16: true
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: false
+  plan_during_train: false
+  plan_during_eval: false
+  support_mode_conditioning: true
+
+policy:
+  backbone:
+    model_name: openai/clip-vit-base-patch32
+    hidden_dim: 64
+    max_text_tokens: 32
+    freeze_backbone: true
+    gradient_checkpointing: false
+    use_dummy_backbone: true
+  fusion:
+    hidden_dim: 64
+    num_cameras: 3
+    num_layers: 2
+    num_heads: 4
+    ff_dim: 128
+    dropout: 0.1
+    proprio_dim: 32
+    proprio_tokens: 1
+  memory:
+    hidden_dim: 64
+    history_steps: 2
+    num_layers: 1
+    dropout: 0.1
+  decoder:
+    hidden_dim: 64
+    num_heads: 4
+    num_layers: 2
+    ff_dim: 128
+    dropout: 0.1
+    chunk_size: 4
+    action_dim: 14
+    arm_action_dim: 7
+    num_candidates: 4
+  reveal_head:
+    hidden_dim: 64
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 3
+    belief_map_size: 32
+    field_size: 16
+    num_heads: 4
+    predict_belief_map: true
+  world_model:
+    hidden_dim: 64
+    action_dim: 14
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 3
+  planner:
+    hidden_dim: 64
+    num_candidates: 4
+    action_dim: 14
+    utility_margin: 0.1
+
+loss_weights:
+  action: 1.0
+  support_mode: 0.0
+  corridor: 0.0
+  persistence: 0.0
+  disturbance: 0.0
+  world_model: 0.0
+  belief: 0.0
+  planner_success: 0.0
+  planner_risk: 0.0
+  planner_ranking: 0.0

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_ablation_nodepth.yaml

@@ -0,0 +1,16 @@
+experiment_name: proxy_interaction_r3d_ablation_nodepth
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 17
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 224, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_clip224_v6_rgbd_stage3.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage3.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 17}
+optim: {epochs: 4, batch_size: 2, num_workers: 0, lr: 0.0003, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: true, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: true, plan_during_eval: true, support_mode_conditioning: true, planner_mode: trainable, use_depth: false, use_world_model: true, use_role_tokens: true, compute_equivariance_probe: true}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 512, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: false}
+  fusion: {hidden_dim: 512, num_cameras: 3, num_layers: 4, num_heads: 8, ff_dim: 2048, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 512, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 8, max_history_steps: 8}
+  decoder: {hidden_dim: 512, num_heads: 8, num_layers: 4, ff_dim: 2048, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 512, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 8, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 512, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 8, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 512, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 8, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0, phase: 0.1, arm_role: 0.15, support_mode: 0.1, corridor: 0.15, persistence: 0.05, disturbance: 0.05, world_model: 0.25, belief: 0.05, visibility: 0.05, clearance: 0.05, support_stability: 0.05, reocclusion: 0.05, occluder_contact: 0.05, grasp_affordance: 0.05, planner_success: 0.25, planner_risk: 0.1, planner_ranking: 0.2, proposal_reconstruction: 0.1, proposal_success: 0.15, proposal_ranking: 0.2, proposal_diversity: 0.05, role_swap_consistency: 0.05}

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_ablation_noplanner.yaml

@@ -0,0 +1,16 @@
+experiment_name: proxy_interaction_r3d_ablation_noplanner
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 17
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 96, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_v6_rgbd_stage2_dummy.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_v6_rgbd_stage2_dummy.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 17}
+optim: {epochs: 10, batch_size: 16, num_workers: 0, lr: 0.001, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: false, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: false, plan_during_eval: false, support_mode_conditioning: true, planner_mode: off, use_depth: false, use_world_model: true, use_role_tokens: true, compute_equivariance_probe: true}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 192, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: true}
+  fusion: {hidden_dim: 192, num_cameras: 3, num_layers: 2, num_heads: 4, ff_dim: 384, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 192, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 4, max_history_steps: 8}
+  decoder: {hidden_dim: 192, num_heads: 4, num_layers: 2, ff_dim: 384, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 192, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 4, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 192, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 4, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 192, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 4, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0}

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_ablation_norolesym.yaml

@@ -0,0 +1,16 @@
+experiment_name: proxy_interaction_r3d_ablation_norolesym
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 17
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 96, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_v6_rgbd_stage2_dummy.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_v6_rgbd_stage2_dummy.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 17}
+optim: {epochs: 10, batch_size: 16, num_workers: 0, lr: 0.001, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: false, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: true, plan_during_eval: true, support_mode_conditioning: true, planner_mode: trainable, use_depth: false, use_world_model: true, use_role_tokens: false, compute_equivariance_probe: false}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 192, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: true}
+  fusion: {hidden_dim: 192, num_cameras: 3, num_layers: 2, num_heads: 4, ff_dim: 384, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 192, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 4, max_history_steps: 8}
+  decoder: {hidden_dim: 192, num_heads: 4, num_layers: 2, ff_dim: 384, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 192, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 4, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 192, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 4, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 192, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 4, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0}

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_ablation_nowm.yaml

@@ -0,0 +1,16 @@
+experiment_name: proxy_interaction_r3d_ablation_nowm
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 17
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 96, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_v6_rgbd_stage2_dummy.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_v6_rgbd_stage2_dummy.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 17}
+optim: {epochs: 10, batch_size: 16, num_workers: 0, lr: 0.001, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: false, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: true, plan_during_eval: true, support_mode_conditioning: true, planner_mode: trainable, use_depth: false, use_world_model: false, use_role_tokens: true, compute_equivariance_probe: true}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 192, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: true}
+  fusion: {hidden_dim: 192, num_cameras: 3, num_layers: 2, num_heads: 4, ff_dim: 384, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 192, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 4, max_history_steps: 8}
+  decoder: {hidden_dim: 192, num_heads: 4, num_layers: 2, ff_dim: 384, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 192, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 4, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 192, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 4, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 192, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 4, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0}

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_stage1_clip.yaml

@@ -0,0 +1,72 @@
+experiment_name: proxy_interaction_r3d_stage1_clip
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 7
+init_checkpoint: /workspace/VLAarchtests/artifacts/outputs/reveal_runs/proxy_backbone_only_clip/checkpoint_best.pt
+init_strict: false
+
+data:
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  resolution: 224
+  dataset_version: reveal_proxy_v6_rgbd_elastic_state
+  train_episodes_per_proxy: 48
+  val_episodes_per_proxy: 16
+  train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_clip224_v6_rgbd_stage1.pt
+  val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage1.pt
+  rebuild_dataset: false
+  chunk_horizon: 8
+  rollout_horizon: 5
+  history_steps: 6
+  planner_candidates: 8
+  seed: 7
+
+optim: {epochs: 4, batch_size: 2, num_workers: 4, lr: 0.0003, weight_decay: 0.0001}
+
+trainer:
+  policy_type: elastic_reveal
+  use_bf16: true
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: false
+  plan_during_train: true
+  plan_during_eval: true
+  support_mode_conditioning: true
+  planner_mode: trainable
+  use_depth: false
+  use_world_model: true
+  use_role_tokens: true
+  compute_equivariance_probe: true
+
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 512, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: false}
+  fusion: {hidden_dim: 512, num_cameras: 3, num_layers: 4, num_heads: 8, ff_dim: 2048, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 512, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 8, max_history_steps: 8}
+  decoder: {hidden_dim: 512, num_heads: 8, num_layers: 4, ff_dim: 2048, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 512, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 8, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 512, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 8, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 512, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 8, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+
+loss_weights:
+  action: 1.0
+  phase: 0.1
+  arm_role: 0.15
+  support_mode: 0.1
+  corridor: 0.15
+  persistence: 0.05
+  disturbance: 0.05
+  world_model: 0.2
+  belief: 0.05
+  visibility: 0.05
+  clearance: 0.05
+  support_stability: 0.05
+  reocclusion: 0.05
+  occluder_contact: 0.05
+  grasp_affordance: 0.05
+  planner_success: 0.25
+  planner_risk: 0.1
+  planner_ranking: 0.2
+  proposal_reconstruction: 0.1
+  proposal_success: 0.15
+  proposal_ranking: 0.2
+  proposal_diversity: 0.05
+  role_swap_consistency: 0.05

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_stage1_dummy.yaml

@@ -0,0 +1,75 @@
+experiment_name: proxy_interaction_r3d_stage1_dummy
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 13
+
+data:
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  resolution: 96
+  dataset_version: reveal_proxy_v6_rgbd_elastic_state
+  train_episodes_per_proxy: 48
+  val_episodes_per_proxy: 16
+  train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_v6_rgbd_stage1_dummy.pt
+  val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_v6_rgbd_stage1_dummy.pt
+  rebuild_dataset: false
+  chunk_horizon: 8
+  rollout_horizon: 5
+  history_steps: 6
+  planner_candidates: 8
+  seed: 13
+
+optim:
+  epochs: 4
+  batch_size: 16
+  num_workers: 4
+  lr: 0.001
+  weight_decay: 0.0001
+
+trainer:
+  policy_type: elastic_reveal
+  use_bf16: false
+  grad_clip_norm: 1.0
+  freeze_backbone: true
+  gradient_checkpointing: false
+  plan_during_train: true
+  plan_during_eval: true
+  support_mode_conditioning: true
+  planner_mode: trainable
+  use_depth: false
+  use_world_model: true
+  use_role_tokens: true
+  compute_equivariance_probe: true
+
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 192, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: true}
+  fusion: {hidden_dim: 192, num_cameras: 3, num_layers: 2, num_heads: 4, ff_dim: 384, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 192, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 4, max_history_steps: 8}
+  decoder: {hidden_dim: 192, num_heads: 4, num_layers: 2, ff_dim: 384, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 192, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 4, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 192, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 4, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 192, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 4, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+
+loss_weights:
+  action: 1.0
+  phase: 0.15
+  arm_role: 0.2
+  support_mode: 0.15
+  corridor: 0.2
+  persistence: 0.1
+  disturbance: 0.1
+  world_model: 0.25
+  belief: 0.05
+  visibility: 0.05
+  clearance: 0.05
+  support_stability: 0.05
+  reocclusion: 0.05
+  occluder_contact: 0.05
+  grasp_affordance: 0.05
+  planner_success: 0.2
+  planner_risk: 0.1
+  planner_ranking: 0.1
+  proposal_reconstruction: 0.2
+  proposal_success: 0.1
+  proposal_ranking: 0.1
+  proposal_diversity: 0.05
+  role_swap_consistency: 0.05

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_stage2_clip.yaml

@@ -0,0 +1,18 @@
+experiment_name: proxy_interaction_r3d_stage2_clip
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 11
+init_checkpoint: /workspace/VLAarchtests/artifacts/outputs/reveal_runs/proxy_backbone_only_clip/checkpoint_best.pt
+init_strict: false
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 224, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_clip224_v6_rgbd_stage2.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage2.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 11}
+optim: {epochs: 4, batch_size: 2, num_workers: 4, lr: 0.0003, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: true, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: true, plan_during_eval: true, support_mode_conditioning: true, planner_mode: trainable, use_depth: false, use_world_model: true, use_role_tokens: true, compute_equivariance_probe: true}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 512, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: false}
+  fusion: {hidden_dim: 512, num_cameras: 3, num_layers: 4, num_heads: 8, ff_dim: 2048, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 512, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 8, max_history_steps: 8}
+  decoder: {hidden_dim: 512, num_heads: 8, num_layers: 4, ff_dim: 2048, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 512, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 8, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 512, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 8, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 512, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 8, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0, phase: 0.1, arm_role: 0.15, support_mode: 0.1, corridor: 0.15, persistence: 0.05, disturbance: 0.05, world_model: 0.25, belief: 0.05, visibility: 0.05, clearance: 0.05, support_stability: 0.05, reocclusion: 0.05, occluder_contact: 0.05, grasp_affordance: 0.05, planner_success: 0.25, planner_risk: 0.1, planner_ranking: 0.2, proposal_reconstruction: 0.1, proposal_success: 0.15, proposal_ranking: 0.2, proposal_diversity: 0.05, role_swap_consistency: 0.05}

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_stage2_dummy.yaml

@@ -0,0 +1,17 @@
+experiment_name: proxy_interaction_r3d_stage2_dummy
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 21
+defaults: []
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 96, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_v6_rgbd_stage2_dummy.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_v6_rgbd_stage2_dummy.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 21}
+optim: {epochs: 4, batch_size: 16, num_workers: 4, lr: 0.001, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: false, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: true, plan_during_eval: true, support_mode_conditioning: true, planner_mode: trainable, use_depth: false, use_world_model: true, use_role_tokens: true, compute_equivariance_probe: true}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 192, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: true}
+  fusion: {hidden_dim: 192, num_cameras: 3, num_layers: 2, num_heads: 4, ff_dim: 384, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 192, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 4, max_history_steps: 8}
+  decoder: {hidden_dim: 192, num_heads: 4, num_layers: 2, ff_dim: 384, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 192, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 4, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 192, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 4, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 192, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 4, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0, phase: 0.15, arm_role: 0.2, support_mode: 0.15, corridor: 0.2, persistence: 0.1, disturbance: 0.1, world_model: 0.3, belief: 0.05, visibility: 0.05, clearance: 0.05, support_stability: 0.05, reocclusion: 0.05, occluder_contact: 0.05, grasp_affordance: 0.05, planner_success: 0.2, planner_risk: 0.1, planner_ranking: 0.1, proposal_reconstruction: 0.2, proposal_success: 0.1, proposal_ranking: 0.1, proposal_diversity: 0.05, role_swap_consistency: 0.05}

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/proxy_interaction_r3d_stage3_clip_rgbd.yaml

@@ -0,0 +1,18 @@
+experiment_name: proxy_interaction_r3d_stage3_clip_rgbd
+output_dir: /workspace/VLAarchtests/artifacts/outputs/r3d
+device: cuda
+seed: 17
+init_checkpoint: /workspace/VLAarchtests/artifacts/outputs/reveal_runs/proxy_backbone_only_clip/checkpoint_best.pt
+init_strict: false
+data: {proxies: [foliage_proxy, bag_proxy, cloth_proxy], resolution: 224, dataset_version: reveal_proxy_v6_rgbd_elastic_state, train_episodes_per_proxy: 48, val_episodes_per_proxy: 16, train_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_train_clip224_v6_rgbd_stage3.pt, val_dataset_path: /workspace/VLAarchtests/artifacts/data/reveal_proxy/proxy_val_clip224_v6_rgbd_stage3.pt, rebuild_dataset: false, chunk_horizon: 8, rollout_horizon: 5, history_steps: 6, planner_candidates: 8, seed: 17}
+optim: {epochs: 4, batch_size: 2, num_workers: 4, lr: 0.0003, weight_decay: 0.0001}
+trainer: {policy_type: elastic_reveal, use_bf16: true, grad_clip_norm: 1.0, freeze_backbone: true, gradient_checkpointing: false, plan_during_train: true, plan_during_eval: true, support_mode_conditioning: true, planner_mode: trainable, use_depth: true, use_world_model: true, use_role_tokens: true, compute_equivariance_probe: true}
+policy:
+  backbone: {model_name: openai/clip-vit-base-patch32, hidden_dim: 512, max_text_tokens: 32, freeze_backbone: true, gradient_checkpointing: false, use_dummy_backbone: false}
+  fusion: {hidden_dim: 512, num_cameras: 3, num_layers: 4, num_heads: 8, ff_dim: 2048, dropout: 0.1, proprio_dim: 32, proprio_tokens: 1}
+  memory: {hidden_dim: 512, action_dim: 14, history_steps: 6, scene_history_steps: 3, belief_history_steps: 8, num_layers: 2, dropout: 0.1, memory_bank_size: 4, scene_bank_size: 2, belief_bank_size: 2, num_heads: 8, max_history_steps: 8}
+  decoder: {hidden_dim: 512, num_heads: 8, num_layers: 4, ff_dim: 2048, dropout: 0.1, chunk_size: 8, action_dim: 14, arm_action_dim: 7, num_candidates: 8, num_phases: 5, num_arm_roles: 4, num_proposal_modes: 6, planner_top_k: 4}
+  reveal_head: {hidden_dim: 512, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, belief_map_size: 32, field_size: 16, num_heads: 8, predict_belief_map: true, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8}
+  world_model: {hidden_dim: 512, action_dim: 14, num_support_modes: 3, num_approach_templates: 32, rollout_horizon: 5, field_size: 16, num_heads: 8, num_phases: 5, num_arm_roles: 4, num_interaction_tokens: 8, belief_map_size: 32, predict_belief_map: true, scene_bank_size: 2, belief_bank_size: 2}
+  planner: {hidden_dim: 512, num_candidates: 8, action_dim: 14, num_support_modes: 3, utility_margin: 0.1, num_heads: 8, num_layers: 2, num_phases: 5, num_arm_roles: 4, top_k: 4}
+loss_weights: {action: 1.0, phase: 0.1, arm_role: 0.15, support_mode: 0.1, corridor: 0.15, persistence: 0.05, disturbance: 0.05, world_model: 0.25, belief: 0.05, visibility: 0.05, clearance: 0.05, support_stability: 0.05, reocclusion: 0.05, occluder_contact: 0.05, grasp_affordance: 0.05, planner_success: 0.25, planner_risk: 0.1, planner_ranking: 0.2, proposal_reconstruction: 0.1, proposal_success: 0.15, proposal_ranking: 0.2, proposal_diversity: 0.05, role_swap_consistency: 0.05}