Add files using upload-large-folder tool

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/data/reveal_proxies.yaml

@@ -0,0 +1,9 @@
+dataset:
+  name: reveal_proxies
+  proxies: [foliage_proxy, bag_proxy, cloth_proxy]
+  image_resolution: 224
+  chunk_size: 8
+  action_dim: 14
+  num_support_modes: 3
+  num_approach_templates: 32
+  rollout_horizon: 5

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/train/configs/data/rlbench_3cam.yaml

@@ -0,0 +1,8 @@
+dataset:
+  name: rlbench_3cam
+  cameras: [front, wrist_left, wrist_right]
+  image_resolution: 224
+  chunk_size: 8
+  action_dim: 14
+  include_point_cloud_for_peract2: true
+  task_split: peract2

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

@@ -0,0 +1,47 @@
+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
+  reveal_head:
+    hidden_dim: 512
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 5
+    belief_map_size: 32
+    predict_belief_map: false
+  world_model:
+    hidden_dim: 512
+    action_dim: 14
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 5
+  planner:
+    num_candidates: 8
+    corridor_weight: 1.0
+    persistence_weight: 0.5
+    proposal_weight: 0.5
+    disturbance_weight: 0.75
+    reocclusion_weight: 0.5
+    visibility_weight: 0.25

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

@@ -0,0 +1,97 @@
+experiment_name: rlbench_subset3_reveal_state_dummy
+output_dir: /workspace/outputs/rlbench_custom
+device: cuda
+seed: 7
+init_checkpoint: /workspace/outputs/reveal_runs/proxy_reveal_state/checkpoint_best.pt
+init_strict: false
+
+data:
+  dataset_root: /workspace/data/rlbench2
+  tasks: [bimanual_lift_ball, bimanual_push_box, bimanual_dual_push_buttons]
+  train_episodes: [0]
+  val_episodes: [1]
+  resolution: 224
+  chunk_horizon: 8
+  proprio_dim: 32
+  history_steps: 2
+
+optim:
+  epochs: 2
+  batch_size: 4
+  num_workers: 0
+  lr: 0.0005
+  weight_decay: 0.0001
+
+trainer:
+  policy_type: reveal_state
+  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: 128
+    max_text_tokens: 32
+    freeze_backbone: true
+    gradient_checkpointing: false
+    use_dummy_backbone: true
+  fusion:
+    hidden_dim: 128
+    num_cameras: 3
+    num_layers: 2
+    num_heads: 4
+    ff_dim: 256
+    dropout: 0.1
+    proprio_dim: 32
+    proprio_tokens: 1
+  memory:
+    hidden_dim: 128
+    history_steps: 2
+    num_layers: 1
+    dropout: 0.1
+  decoder:
+    hidden_dim: 128
+    num_heads: 4
+    num_layers: 2
+    ff_dim: 256
+    dropout: 0.1
+    chunk_size: 8
+    action_dim: 14
+    num_candidates: 8
+  reveal_head:
+    hidden_dim: 128
+    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
+  world_model:
+    hidden_dim: 128
+    action_dim: 14
+    num_support_modes: 3
+    num_approach_templates: 32
+    rollout_horizon: 5
+  planner:
+    hidden_dim: 128
+    num_candidates: 8
+    action_dim: 14
+    utility_margin: 0.1
+
+loss_weights:
+  action: 1.0
+  support_mode: 0.15
+  corridor: 0.2
+  persistence: 0.1
+  disturbance: 0.1
+  world_model: 0.2
+  belief: 0.05
+  planner_success: 0.0
+  planner_risk: 0.0
+  planner_ranking: 0.0

code/VLAarchtests2_code/VLAarchtests/tests/conftest.py

@@ -0,0 +1,178 @@
+import sys
+from pathlib import Path
+
+import pytest
+import torch
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO_ROOT / "code" / "reveal_vla_bimanual"))
+
+from models.action_decoder import ChunkDecoderConfig
+from models.backbones import FrozenVLBackboneConfig
+from models.multiview_fusion import MultiViewFusionConfig
+from models.observation_memory import ObservationMemoryConfig
+from models.planner import PlannerConfig
+from models.policy import PolicyConfig
+from models.reveal_head import RevealHeadConfig
+from models.world_model import RevealWMConfig
+from train.trainer import TrainerConfig
+
+
+@pytest.fixture
+def tiny_policy_config():
+    def _factory(
+        hidden_dim: int = 16,
+        chunk_size: int = 2,
+        num_candidates: int = 4,
+        top_k: int = 2,
+        field_size: int = 4,
+        belief_map_size: int = 8,
+    ) -> PolicyConfig:
+        return PolicyConfig(
+            backbone=FrozenVLBackboneConfig(
+                hidden_dim=hidden_dim,
+                freeze_backbone=True,
+                gradient_checkpointing=False,
+                use_dummy_backbone=True,
+                depth_patch_size=8,
+            ),
+            fusion=MultiViewFusionConfig(
+                hidden_dim=hidden_dim,
+                num_layers=1,
+                num_heads=4,
+                ff_dim=hidden_dim * 4,
+                dropout=0.0,
+            ),
+            memory=ObservationMemoryConfig(
+                hidden_dim=hidden_dim,
+                num_heads=4,
+                dropout=0.0,
+                history_steps=2,
+                scene_history_steps=2,
+                belief_history_steps=3,
+                max_history_steps=4,
+                scene_bank_size=2,
+                belief_bank_size=2,
+            ),
+            decoder=ChunkDecoderConfig(
+                hidden_dim=hidden_dim,
+                num_heads=4,
+                num_layers=1,
+                ff_dim=hidden_dim * 4,
+                dropout=0.0,
+                chunk_size=chunk_size,
+                num_candidates=num_candidates,
+                num_proposal_modes=7,
+                planner_top_k=top_k,
+            ),
+            reveal_head=RevealHeadConfig(
+                hidden_dim=hidden_dim,
+                num_heads=4,
+                field_size=field_size,
+                belief_map_size=belief_map_size,
+                predict_belief_map=True,
+            ),
+            world_model=RevealWMConfig(
+                hidden_dim=hidden_dim,
+                num_heads=4,
+                field_size=field_size,
+                belief_map_size=belief_map_size,
+                scene_bank_size=2,
+                belief_bank_size=2,
+            ),
+            planner=PlannerConfig(
+                hidden_dim=hidden_dim,
+                num_heads=4,
+                num_layers=1,
+                num_candidates=num_candidates,
+                top_k=top_k,
+            ),
+        )
+
+    return _factory
+
+
+@pytest.fixture
+def tiny_trainer_config():
+    def _factory(policy_type: str = "elastic_reveal") -> TrainerConfig:
+        return TrainerConfig(
+            policy_type=policy_type,
+            use_bf16=False,
+            gradient_checkpointing=False,
+            freeze_backbone=True,
+            plan_during_train=True,
+            plan_during_eval=True,
+        )
+
+    return _factory
+
+
+@pytest.fixture
+def tiny_batch():
+    def _factory(
+        batch_size: int = 2,
+        history_steps: int = 2,
+        resolution: int = 16,
+        chunk_size: int = 2,
+    ) -> dict[str, torch.Tensor | list[str]]:
+        images = torch.rand(batch_size, 3, 3, resolution, resolution)
+        depths = torch.rand(batch_size, 3, 1, resolution, resolution)
+        batch = {
+            "images": images,
+            "depths": depths,
+            "depth_valid": torch.ones_like(depths),
+            "camera_intrinsics": torch.eye(3).view(1, 1, 3, 3).expand(batch_size, 3, 3, 3).clone(),
+            "camera_extrinsics": torch.eye(4).view(1, 1, 4, 4).expand(batch_size, 3, 4, 4).clone(),
+            "camera_valid_mask": torch.ones(batch_size, 3),
+            "proprio": torch.rand(batch_size, 32),
+            "texts": ["test task"] * batch_size,
+            "task_name": ["bag"] * batch_size,
+            "task_id": torch.ones(batch_size, dtype=torch.long),
+            "task_names": ["bag"] * batch_size,
+            "task_ids": torch.ones(batch_size, dtype=torch.long),
+            "history_images": torch.rand(batch_size, history_steps, 3, 3, resolution, resolution),
+            "history_depths": torch.rand(batch_size, history_steps, 3, 1, resolution, resolution),
+            "history_depth_valid": torch.ones(batch_size, history_steps, 3, 1, resolution, resolution),
+            "history_camera_intrinsics": torch.eye(3).view(1, 1, 1, 3, 3).expand(batch_size, history_steps, 3, 3, 3).clone(),
+            "history_camera_extrinsics": torch.eye(4).view(1, 1, 1, 4, 4).expand(batch_size, history_steps, 3, 4, 4).clone(),
+            "history_camera_valid_mask": torch.ones(batch_size, history_steps, 3),
+            "history_proprio": torch.rand(batch_size, history_steps, 32),
+            "history_actions": torch.rand(batch_size, history_steps, 14),
+            "action_chunk": torch.rand(batch_size, chunk_size, 14),
+        }
+        return batch
+
+    return _factory
+
+
+@pytest.fixture
+def tiny_state():
+    def _factory(batch_size: int = 2, field_size: int = 4) -> dict[str, torch.Tensor]:
+        return {
+            "target_belief_field": torch.rand(batch_size, 1, field_size, field_size),
+            "visibility_field": torch.rand(batch_size, 1, field_size, field_size),
+            "clearance_field": torch.rand(batch_size, 2, field_size, field_size),
+            "occluder_contact_field": torch.rand(batch_size, 1, field_size, field_size),
+            "grasp_affordance_field": torch.rand(batch_size, 1, field_size, field_size),
+            "support_stability_field": torch.rand(batch_size, 1, field_size, field_size),
+            "persistence_field": torch.rand(batch_size, 1, field_size, field_size),
+            "reocclusion_field": torch.rand(batch_size, 1, field_size, field_size),
+            "disturbance_field": torch.rand(batch_size, 1, field_size, field_size),
+            "risk_field": torch.rand(batch_size, 1, field_size, field_size),
+            "uncertainty_field": torch.rand(batch_size, 1, field_size, field_size),
+            "access_field": torch.rand(batch_size, 3, field_size, field_size),
+            "support_mode_logits": torch.rand(batch_size, 3),
+            "phase_logits": torch.rand(batch_size, 5),
+            "arm_role_logits": torch.rand(batch_size, 2, 4),
+            "interaction_tokens": torch.rand(batch_size, 8, 16),
+            "field_tokens": torch.rand(batch_size, field_size * field_size, 16),
+            "latent_summary": torch.rand(batch_size, 16),
+            "corridor_logits": torch.rand(batch_size, 3, 32),
+            "persistence_horizon": torch.rand(batch_size, 3),
+            "disturbance_cost": torch.rand(batch_size),
+            "reocclusion_logit": torch.rand(batch_size, 3),
+            "belief_map": torch.rand(batch_size, 1, 8, 8),
+            "compact_state": torch.rand(batch_size, 30),
+        }
+
+    return _factory

code/VLAarchtests2_code/VLAarchtests/tests/test_anybimanual_overlap_eval_summary.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from eval.summarize_anybimanual_overlap_eval import (
+    _best_overlap_step,
+    _delta,
+    _last_overlap_step,
+    _merge_rows_by_step,
+)
+
+
+def _row(step: int, **values: str) -> dict[str, str]:
+    base = {"step": str(step)}
+    base.update(values)
+    return base
+
+
+def test_merge_rows_by_step_fills_missing_values() -> None:
+    rows = [
+        _row(600, **{"eval_envs/return/coordinated_push_box": "10"}),
+        _row(600, **{"eval_envs/return/coordinated_lift_ball": "4"}),
+        _row(600, **{"eval_envs/return/dual_push_buttons": "20"}),
+    ]
+    merged = _merge_rows_by_step(rows)
+    assert len(merged) == 1
+    assert merged[0]["eval_envs/return/coordinated_push_box"] == "10"
+    assert merged[0]["eval_envs/return/coordinated_lift_ball"] == "4"
+    assert merged[0]["eval_envs/return/dual_push_buttons"] == "20"
+
+
+def test_overlap_summary_picks_last_local_and_best_public() -> None:
+    local_rows = _merge_rows_by_step(
+        [
+            _row(
+                200,
+                **{
+                    "eval_envs/return/coordinated_push_box": "0",
+                    "eval_envs/return/coordinated_lift_ball": "0",
+                    "eval_envs/return/dual_push_buttons": "0",
+                },
+            ),
+            _row(
+                1000,
+                **{
+                    "eval_envs/return/coordinated_push_box": "15",
+                    "eval_envs/return/coordinated_lift_ball": "8",
+                    "eval_envs/return/dual_push_buttons": "20",
+                },
+            ),
+        ]
+    )
+    public_rows = _merge_rows_by_step(
+        [
+            _row(
+                50000,
+                **{
+                    "eval_envs/return/coordinated_push_box": "18",
+                    "eval_envs/return/coordinated_lift_ball": "6",
+                    "eval_envs/return/dual_push_buttons": "20",
+                },
+            ),
+            _row(
+                60000,
+                **{
+                    "eval_envs/return/coordinated_push_box": "20",
+                    "eval_envs/return/coordinated_lift_ball": "8",
+                    "eval_envs/return/dual_push_buttons": "24",
+                },
+            ),
+        ]
+    )
+    local_last = _last_overlap_step(local_rows, 25)
+    public_best = _best_overlap_step(public_rows, 25)
+    assert local_last["step"] == 1000
+    assert public_best["step"] == 60000
+    assert public_best["mean_success"] > local_last["mean_success"]
+    delta = _delta(local_last, public_best)
+    assert delta["mean_success_delta"] < 0.0

code/VLAarchtests2_code/VLAarchtests/tests/test_anybimanual_resume_logic.py

@@ -0,0 +1,73 @@
+import os
+import tempfile
+
+from yarr.runners.weight_init_utils import resolve_initial_weight_state
+
+
+def _make_weight_dir(root, step):
+    os.makedirs(os.path.join(root, str(step)), exist_ok=True)
+
+
+def test_anybimanual_prefers_existing_weights_when_resume_enabled():
+    with tempfile.TemporaryDirectory() as weightsdir, tempfile.TemporaryDirectory() as pretrained_dir:
+        _make_weight_dir(weightsdir, 0)
+        _make_weight_dir(weightsdir, 200)
+
+        start_iter, load_dir, load_source = resolve_initial_weight_state(
+            weightsdir=weightsdir,
+            load_existing_weights=True,
+            anybimanual=True,
+            pretrained_dir=pretrained_dir,
+        )
+
+        assert start_iter == 200
+        assert load_dir == os.path.join(weightsdir, "200")
+        assert load_source == "resume"
+
+
+def test_anybimanual_falls_back_to_pretrained_without_existing_weights():
+    with tempfile.TemporaryDirectory() as weightsdir, tempfile.TemporaryDirectory() as pretrained_dir:
+        start_iter, load_dir, load_source = resolve_initial_weight_state(
+            weightsdir=weightsdir,
+            load_existing_weights=True,
+            anybimanual=True,
+            pretrained_dir=pretrained_dir,
+        )
+
+        assert start_iter == 0
+        assert load_dir == pretrained_dir
+        assert load_source == "pretrained"
+
+
+def test_non_anybimanual_with_no_resume_starts_fresh():
+    with tempfile.TemporaryDirectory() as weightsdir:
+        _make_weight_dir(weightsdir, 0)
+        _make_weight_dir(weightsdir, 200)
+
+        start_iter, load_dir, load_source = resolve_initial_weight_state(
+            weightsdir=weightsdir,
+            load_existing_weights=False,
+            anybimanual=False,
+        )
+
+        assert start_iter == 0
+        assert load_dir is None
+        assert load_source is None
+
+
+def test_anybimanual_raises_when_pretrained_dir_missing():
+    with tempfile.TemporaryDirectory() as weightsdir:
+        missing_pretrained = os.path.join(weightsdir, "missing_pretrained")
+
+        try:
+            resolve_initial_weight_state(
+                weightsdir=weightsdir,
+                load_existing_weights=False,
+                anybimanual=True,
+                pretrained_dir=missing_pretrained,
+            )
+            raised = False
+        except FileNotFoundError:
+            raised = True
+
+        assert raised

code/VLAarchtests2_code/VLAarchtests/tests/test_backbone_only_rgbd_forward.py

@@ -0,0 +1,27 @@
+from train.trainer import build_policy
+
+
+def test_backbone_only_policy_accepts_rgbd_batch(tiny_policy_config, tiny_trainer_config, tiny_batch):
+    config = tiny_policy_config()
+    batch = tiny_batch(chunk_size=config.decoder.chunk_size)
+    policy = build_policy(config, tiny_trainer_config(policy_type="backbone_only"))
+
+    output = policy(
+        images=batch["images"],
+        depths=batch["depths"],
+        depth_valid=batch["depth_valid"],
+        camera_intrinsics=batch["camera_intrinsics"],
+        camera_extrinsics=batch["camera_extrinsics"],
+        proprio=batch["proprio"],
+        texts=batch["texts"],
+        history_images=batch["history_images"],
+        history_depths=batch["history_depths"],
+        history_depth_valid=batch["history_depth_valid"],
+        history_camera_intrinsics=batch["history_camera_intrinsics"],
+        history_camera_extrinsics=batch["history_camera_extrinsics"],
+        history_proprio=batch["history_proprio"],
+        history_actions=batch["history_actions"],
+    )
+
+    assert output["action_mean"].shape[0] == batch["images"].shape[0]
+    assert output["scene_tokens"].shape[0] == batch["images"].shape[0]

code/VLAarchtests2_code/VLAarchtests/tests/test_build_task_specialized_episode_specs.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_build_task_specialized_episode_specs(tmp_path: Path) -> None:
+    output_path = tmp_path / "specs.json"
+    script_path = Path("/workspace/VLAarchtests/code/reveal_vla_bimanual/sim_reveal/build_task_specialized_episode_specs.py")
+
+    subprocess.run(
+        [
+            sys.executable,
+            str(script_path),
+            "--task-name",
+            "bag",
+            "--base-seed",
+            "123",
+            "--block",
+            "nominal,medium,2",
+            "--block",
+            "one_sided_slip,hard,3",
+            "--output-path",
+            str(output_path),
+        ],
+        check=True,
+    )
+
+    specs = json.loads(output_path.read_text(encoding="utf-8"))
+    assert len(specs) == 5
+    assert all(spec["proxy_name"] == "bag_proxy" for spec in specs)
+    assert all(spec["task_name"] == "bag" for spec in specs)
+    assert all(spec["task_id"] == 1 for spec in specs)
+    assert specs[0]["stress_slice"] == "nominal"
+    assert specs[0]["difficulty_bin"] == "medium"
+    assert specs[-1]["stress_slice"] == "one_sided_slip"
+    assert specs[-1]["difficulty_bin"] == "hard"

code/VLAarchtests2_code/VLAarchtests/tests/test_dataset_hard_negative_presence.py

@@ -0,0 +1,25 @@
+from sim_reveal.dataset import collect_teacher_dataset
+from sim_reveal.procedural_envs import available_proxy_names
+
+
+def test_dataset_hard_negative_presence():
+    dataset_bundle = collect_teacher_dataset(
+        proxy_names=available_proxy_names(),
+        episodes_per_proxy=1,
+        resolution=32,
+        seed=3,
+        chunk_horizon=4,
+        rollout_horizon=4,
+        planner_candidates=6,
+    )
+    negative_families = set()
+    hard_negative_count = 0
+    for sample in dataset_bundle["samples"]:
+        hard_negative_count += int(sum(sample["candidate_is_hard_negative"]))
+        negative_families.update(
+            family
+            for family in sample["candidate_negative_families"]
+            if family not in {"teacher", "positive"}
+        )
+    assert hard_negative_count > 0
+    assert {"premature_retrieve", "reveal_with_release"}.issubset(negative_families)

code/VLAarchtests2_code/VLAarchtests/tests/test_proposal_mode_names_label_base_action.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import torch
+
+from models.action_decoder import ChunkDecoderConfig, SymmetricCoordinatedChunkDecoder
+
+
+def test_proposal_mode_names_label_slot0_as_base_action() -> None:
+    config = ChunkDecoderConfig(
+        hidden_dim=32,
+        num_heads=4,
+        num_layers=1,
+        ff_dim=64,
+        dropout=0.0,
+        chunk_size=2,
+        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,
+    )
+    decoder = SymmetricCoordinatedChunkDecoder(config)
+    base_action = torch.zeros(1, config.chunk_size, config.action_dim)
+    pooled_context = torch.zeros(1, config.action_dim + (config.hidden_dim * 2))
+
+    _, _, _, proposal_mode_names = decoder._proposal_outputs(
+        base_action=base_action,
+        pooled_context=pooled_context,
+        task_names=["bag"],
+    )
+
+    assert proposal_mode_names[0][0] == "base_action"
+    assert "widen_mouth" in proposal_mode_names[0]

code/VLAarchtests2_code/VLAarchtests/tests/test_proposal_semantic_diversity.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+from sim_reveal.procedural_envs import BAG_PROXY, make_proxy_env
+
+
+def test_proposal_semantic_diversity():
+    env = make_proxy_env(proxy_name=BAG_PROXY.name, resolution=32, seed=7, rollout_horizon=4)
+    _, _ = env.reset(seed=7)
+    teacher_chunk, _ = env.teacher_chunk_and_rollout(chunk_horizon=4, rollout_horizon=4)
+    candidates, outcomes = env.sample_candidate_action_chunks(
+        teacher_chunk=teacher_chunk,
+        num_candidates=6,
+        rollout_horizon=4,
+    )
+
+    assert candidates.shape[0] == 6
+    assert len(set(outcomes["candidate_macro_names"])) >= 4
+    assert len(set(outcomes["candidate_negative_families"])) >= 3
+    assert float(np.std(outcomes["candidate_utility"])) > 0.0

code/VLAarchtests2_code/VLAarchtests/tests/test_proxy_scripted_bench.py

@@ -0,0 +1,58 @@
+from sim_reveal.procedural_envs import BAG_PROXY, CLOTH_PROXY, FOLIAGE_PROXY, make_proxy_env
+
+
+def test_proxy_scripted_bench():
+    bag_wins = 0
+    foliage_wins = 0
+    cloth_wins = 0
+    for seed in range(10):
+        bag_env = make_proxy_env(proxy_name=BAG_PROXY.name, resolution=32, seed=seed, rollout_horizon=4)
+        bag_env.reset(seed=seed)
+        maintain = bag_env.evaluate_action_chunk(bag_env.macro_action_chunk("maintain_mouth", chunk_horizon=4), rollout_horizon=4)
+        retrieve = bag_env.evaluate_action_chunk(bag_env.macro_action_chunk("premature_retrieve", chunk_horizon=4), rollout_horizon=4)
+        if (maintain["hold_persistence"] >= retrieve["hold_persistence"]) and (maintain["reocclusion_rate"] <= retrieve["reocclusion_rate"]):
+            bag_wins += 1
+
+        foliage_env = make_proxy_env(proxy_name=FOLIAGE_PROXY.name, resolution=32, seed=seed, rollout_horizon=4)
+        foliage_env.reset(seed=seed)
+        pin = foliage_env.evaluate_action_chunk(foliage_env.macro_action_chunk("pin_canopy", chunk_horizon=4), rollout_horizon=4)
+        swipe = foliage_env.evaluate_action_chunk(foliage_env.macro_action_chunk("foliage_immediate_reocclusion", chunk_horizon=4), rollout_horizon=4)
+        if (pin["reocclusion_rate"] <= swipe["reocclusion_rate"]) and (pin["visibility_integral"] >= swipe["visibility_integral"]):
+            foliage_wins += 1
+
+        cloth_env = make_proxy_env(proxy_name=CLOTH_PROXY.name, resolution=32, seed=seed, rollout_horizon=4)
+        cloth_env.reset(seed=seed)
+        stabilize = cloth_env.evaluate_action_chunk(cloth_env.macro_action_chunk("stabilize_fold", chunk_horizon=4), rollout_horizon=4)
+        lift_high = cloth_env.evaluate_action_chunk(cloth_env.macro_action_chunk("cloth_lift_high", chunk_horizon=4), rollout_horizon=4)
+        if (stabilize["candidate_fold_preservation"] >= lift_high["candidate_fold_preservation"]) and (
+            stabilize["final_disturbance_cost"] <= lift_high["final_disturbance_cost"]
+        ):
+            cloth_wins += 1
+
+    assert bag_wins >= 8
+    assert foliage_wins >= 8
+    assert cloth_wins >= 8
+
+
+def test_cloth_candidate_utility_penalizes_fold_damage():
+    cloth_env = make_proxy_env(proxy_name=CLOTH_PROXY.name, resolution=32, seed=0, rollout_horizon=4)
+    gentle_reveal = {
+        "retrieval_success": 0.0,
+        "final_disturbance_cost": 0.18,
+        "reocclusion_rate": 0.02,
+        "candidate_layer_separation_quality": 0.92,
+        "candidate_fold_preservation": 0.78,
+        "candidate_top_layer_stability": 0.82,
+        "candidate_lift_too_much_risk": 0.08,
+    }
+    destructive_reveal = {
+        "retrieval_success": 0.0,
+        "final_disturbance_cost": 0.52,
+        "reocclusion_rate": 0.02,
+        "candidate_layer_separation_quality": 0.92,
+        "candidate_fold_preservation": 0.06,
+        "candidate_top_layer_stability": 0.18,
+        "candidate_lift_too_much_risk": 0.42,
+    }
+
+    assert cloth_env.candidate_outcome_utility(gentle_reveal) > cloth_env.candidate_outcome_utility(destructive_reveal)

code/VLAarchtests2_code/VLAarchtests/tests/test_reocclusion_memory_regression.py

@@ -0,0 +1,27 @@
+import torch
+
+from models.observation_memory import DualObservationMemory
+
+
+def test_reocclusion_memory_regression(tiny_policy_config):
+    config = tiny_policy_config(hidden_dim=16)
+    config.memory.scene_bank_size = 4
+    config.memory.belief_bank_size = 4
+    memory = DualObservationMemory(config.memory)
+    open_scene = torch.zeros(1, 12, config.backbone.hidden_dim)
+    open_scene[:, :3] = 1.0
+    closed_scene = torch.zeros_like(open_scene)
+    history = torch.stack([open_scene[0], open_scene[0]], dim=0).unsqueeze(0)
+    history_actions = torch.zeros(1, 2, 14)
+
+    closed_output = memory(closed_scene, history_scene_tokens=history, history_actions=history_actions)
+    closed_no_history = memory(
+        closed_scene,
+        history_scene_tokens=torch.zeros_like(history),
+        history_actions=history_actions,
+    )
+    belief_norm = closed_output["belief_memory_tokens"].norm()
+    belief_delta = (closed_output["belief_memory_tokens"] - closed_no_history["belief_memory_tokens"]).norm()
+
+    assert belief_norm > 0.0
+    assert belief_delta > 1e-3

code/VLAarchtests2_code/VLAarchtests/tests/test_retrieve_gating_blocks_premature_retrieve.py

@@ -0,0 +1,39 @@
+import torch
+
+from models.planner import CascadePlanner
+
+
+def test_retrieve_gating_blocks_premature_retrieve(tiny_policy_config, tiny_state):
+    config = tiny_policy_config()
+    planner = CascadePlanner(config.planner)
+    initial_state = {key: value[:1] for key, value in tiny_state(field_size=config.reveal_head.field_size).items()}
+    rollout_horizon = config.world_model.rollout_horizon
+    field_size = config.reveal_head.field_size
+    unsafe = torch.full((1, rollout_horizon, 1, field_size, field_size), 0.05)
+    safe = torch.full((1, rollout_horizon, 1, field_size, field_size), 0.85)
+    unsafe_access = torch.full((1, rollout_horizon, 3, field_size, field_size), -6.0)
+    safe_access = torch.full((1, rollout_horizon, 3, field_size, field_size), 6.0)
+    rollout_state = {
+        "target_belief_field": torch.stack([safe, safe], dim=1),
+        "visibility_field": torch.stack([safe, safe], dim=1),
+        "clearance_field": torch.stack([safe.expand(-1, -1, 2, -1, -1), safe.expand(-1, -1, 2, -1, -1)], dim=1),
+        "occluder_contact_field": torch.stack([safe, safe], dim=1),
+        "grasp_affordance_field": torch.stack([safe, safe], dim=1),
+        "support_stability_field": torch.stack([unsafe, safe], dim=1),
+        "persistence_field": torch.stack([unsafe, safe], dim=1),
+        "reocclusion_field": torch.stack([safe, unsafe], dim=1),
+        "disturbance_field": torch.stack([safe, unsafe], dim=1),
+        "access_field": torch.stack([unsafe_access, safe_access], dim=1),
+    }
+    candidate_chunks = torch.zeros(1, 2, config.decoder.chunk_size, config.decoder.action_dim)
+    candidate_chunks[:, 0, :, -1] = 1.0
+    proposal_mode_names = [["retrieve", "maintain_gap"]]
+
+    selected = planner.select_best(
+        initial_state=initial_state,
+        candidate_chunks=candidate_chunks,
+        rollout_state=rollout_state,
+        proposal_mode_names=proposal_mode_names,
+    )
+
+    assert int(selected["best_indices"].item()) == 1

code/VLAarchtests2_code/VLAarchtests/tests/test_rgb_backward_compat.py

@@ -0,0 +1,33 @@
+from train.trainer import build_policy
+
+
+def test_rgb_backward_compat(tiny_policy_config, tiny_trainer_config, tiny_batch):
+    config = tiny_policy_config()
+    batch = tiny_batch(chunk_size=config.decoder.chunk_size)
+
+    interaction_policy = build_policy(config, tiny_trainer_config(policy_type="interaction_state"))
+    interaction_output = interaction_policy(
+        images=batch["images"],
+        proprio=batch["proprio"],
+        texts=batch["texts"],
+        history_images=batch["history_images"],
+        history_proprio=batch["history_proprio"],
+        history_actions=batch["history_actions"],
+        plan=True,
+    )
+    assert interaction_output["action_mean"].shape[-1] == 14
+    assert interaction_output["candidate_chunks"].shape[1] == config.decoder.num_candidates
+
+    elastic_policy = build_policy(config, tiny_trainer_config(policy_type="elastic_reveal"))
+    elastic_output = elastic_policy(
+        images=batch["images"],
+        proprio=batch["proprio"],
+        texts=batch["texts"],
+        history_images=batch["history_images"],
+        history_proprio=batch["history_proprio"],
+        history_actions=batch["history_actions"],
+        plan=True,
+        use_depth=False,
+    )
+    assert elastic_output["action_mean"].shape[-1] == 14
+    assert elastic_output["planned_chunk"].shape == elastic_output["action_mean"].shape

code/VLAarchtests2_code/VLAarchtests/tests/test_rgbd_forward_contract.py

@@ -0,0 +1,34 @@
+from train.trainer import build_policy
+
+
+def test_rgbd_forward_contract(tiny_policy_config, tiny_trainer_config, tiny_batch):
+    config = tiny_policy_config()
+    batch = tiny_batch(chunk_size=config.decoder.chunk_size)
+    policy = build_policy(config, tiny_trainer_config(policy_type="elastic_reveal"))
+    output = policy(
+        images=batch["images"],
+        depths=batch["depths"],
+        depth_valid=batch["depth_valid"],
+        camera_intrinsics=batch["camera_intrinsics"],
+        camera_extrinsics=batch["camera_extrinsics"],
+        proprio=batch["proprio"],
+        texts=batch["texts"],
+        history_images=batch["history_images"],
+        history_depths=batch["history_depths"],
+        history_depth_valid=batch["history_depth_valid"],
+        history_proprio=batch["history_proprio"],
+        history_actions=batch["history_actions"],
+        plan=True,
+        compute_equivariance_probe=True,
+    )
+    assert output["action_mean"].shape[0] == batch["images"].shape[0]
+    assert output["depth_tokens"] is not None
+    assert output["geometry_tokens"] is not None
+    assert output["camera_tokens"] is not None
+    assert output["proposal_candidates"].shape[1] == config.decoder.num_candidates
+    assert output["planner_topk_indices"].shape[1] == config.planner.top_k
+    assert output["planned_rollout"]["target_belief_field"].shape[1] == config.planner.top_k
+    assert "opening_quality" in output["interaction_state"]
+    assert "gap_width" in output["interaction_state"]
+    assert "hold_quality" in output["interaction_state"]
+    assert output["equivariance_probe_action_mean"].shape == output["equivariance_target_action_mean"].shape

code/VLAarchtests2_code/VLAarchtests/tests/test_rlbench_dataset_rgbd_geometry.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+from PIL import Image
+
+from sim_rlbench.dataset import RLBENCH_DEPTH_SCALE, RLBenchOfflineChunkDataset
+
+
+def _arm(pose_xyz: tuple[float, float, float], gripper_open: float) -> SimpleNamespace:
+    return SimpleNamespace(
+        gripper_pose=np.asarray([*pose_xyz, 0.0, 0.0, 0.0, 1.0], dtype=np.float32),
+        joint_positions=np.linspace(0.0, 0.6, 7, dtype=np.float32),
+        gripper_open=float(gripper_open),
+    )
+
+
+def _encode_depth_png(normalized_depth: np.ndarray) -> Image.Image:
+    scaled = np.clip(np.round(normalized_depth * RLBENCH_DEPTH_SCALE), 0, RLBENCH_DEPTH_SCALE).astype(np.uint32)
+    rgb = np.zeros((*scaled.shape, 3), dtype=np.uint8)
+    rgb[..., 0] = ((scaled >> 16) & 255).astype(np.uint8)
+    rgb[..., 1] = ((scaled >> 8) & 255).astype(np.uint8)
+    rgb[..., 2] = (scaled & 255).astype(np.uint8)
+    return Image.fromarray(rgb, mode="RGB")
+
+
+def _obs(step: int) -> SimpleNamespace:
+    offset = 0.01 * float(step)
+    base_intrinsics = np.array(
+        [
+            [40.0, 0.0, 4.0],
+            [0.0, 40.0, 4.0],
+            [0.0, 0.0, 1.0],
+        ],
+        dtype=np.float32,
+    )
+    return SimpleNamespace(
+        right=_arm((0.10 + offset, 0.20, 0.30), 1.0),
+        left=_arm((-0.10 - offset, 0.15, 0.25), 0.0),
+        misc={
+            "front_camera_intrinsics": base_intrinsics,
+            "wrist_left_camera_intrinsics": base_intrinsics,
+            "wrist_right_camera_intrinsics": base_intrinsics,
+            "front_camera_extrinsics": np.eye(4, dtype=np.float32),
+            "wrist_left_camera_extrinsics": np.eye(4, dtype=np.float32),
+            "wrist_right_camera_extrinsics": np.eye(4, dtype=np.float32),
+            "front_camera_near": 0.2,
+            "wrist_left_camera_near": 0.2,
+            "wrist_right_camera_near": 0.2,
+            "front_camera_far": 1.2,
+            "wrist_left_camera_far": 1.2,
+            "wrist_right_camera_far": 1.2,
+        },
+    )
+
+
+def _write_rgb_frame(directory: Path, step: int, value: int) -> None:
+    directory.mkdir(parents=True, exist_ok=True)
+    image = np.full((8, 8, 3), fill_value=value, dtype=np.uint8)
+    Image.fromarray(image).save(directory / f"rgb_{step:04d}.png")
+
+
+def _write_depth_frame(directory: Path, step: int, depth_value: float) -> None:
+    directory.mkdir(parents=True, exist_ok=True)
+    normalized = np.full((8, 8), fill_value=depth_value, dtype=np.float32)
+    _encode_depth_png(normalized).save(directory / f"depth_{step:04d}.png")
+
+
+def test_rlbench_dataset_emits_rgbd_geometry(tmp_path: Path) -> None:
+    task_name = "bimanual_push_box"
+    episode_dir = tmp_path / task_name / "all_variations" / "episodes" / "episode0"
+    episode_dir.mkdir(parents=True, exist_ok=True)
+
+    with (episode_dir / "variation_descriptions.pkl").open("wb") as handle:
+        pickle.dump(["push the box together"], handle)
+    with (episode_dir / "low_dim_obs.pkl").open("wb") as handle:
+        pickle.dump([_obs(0), _obs(1)], handle)
+
+    for camera_name, pixel_value in (("front", 32), ("wrist_left", 96), ("wrist_right", 160)):
+        camera_dir = episode_dir / f"{camera_name}_rgb"
+        _write_rgb_frame(camera_dir, 0, pixel_value)
+        _write_rgb_frame(camera_dir, 1, pixel_value + 1)
+        depth_dir = episode_dir / f"{camera_name}_depth"
+        _write_depth_frame(depth_dir, 0, 0.5)
+        _write_depth_frame(depth_dir, 1, 0.6)
+
+    dataset = RLBenchOfflineChunkDataset(
+        dataset_root=tmp_path,
+        tasks=[task_name],
+        episode_indices=[0],
+        resolution=4,
+        chunk_size=2,
+        history_steps=1,
+    )
+    item = dataset[0]
+
+    assert tuple(item["depths"].shape) == (3, 1, 4, 4)
+    assert tuple(item["depth_valid"].shape) == (3, 1, 4, 4)
+    assert tuple(item["camera_intrinsics"].shape) == (3, 3, 3)
+    assert tuple(item["camera_extrinsics"].shape) == (3, 4, 4)
+    assert tuple(item["history_depths"].shape) == (1, 3, 1, 4, 4)
+    assert tuple(item["history_camera_intrinsics"].shape) == (1, 3, 3, 3)
+    assert tuple(item["history_camera_extrinsics"].shape) == (1, 3, 4, 4)
+    assert item["camera_valid_mask"].tolist() == [1.0, 1.0, 1.0]
+    assert item["history_camera_valid_mask"].tolist() == [[1.0, 1.0, 1.0]]
+    assert float(item["depths"][0].mean()) > 0.6
+    assert np.isclose(float(item["camera_intrinsics"][0, 0, 0]), 20.0)
+    assert np.isclose(float(item["camera_intrinsics"][0, 1, 1]), 20.0)

code/VLAarchtests2_code/VLAarchtests/tests/test_rlbench_dataset_task_metadata.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+from PIL import Image
+import torch
+from torch.utils.data import DataLoader
+
+from sim_rlbench.dataset import RLBenchOfflineChunkDataset, sample_weight_from_action_norms
+
+
+def _arm(pose_xyz: tuple[float, float, float], gripper_open: float) -> SimpleNamespace:
+    return SimpleNamespace(
+        gripper_pose=np.asarray([*pose_xyz, 0.0, 0.0, 0.0, 1.0], dtype=np.float32),
+        joint_positions=np.linspace(0.0, 0.6, 7, dtype=np.float32),
+        gripper_open=float(gripper_open),
+    )
+
+
+def _obs(step: int) -> SimpleNamespace:
+    offset = 0.01 * float(step)
+    return SimpleNamespace(
+        right=_arm((0.10 + offset, 0.20, 0.30), 1.0),
+        left=_arm((-0.10 - offset, 0.15, 0.25), 0.0),
+    )
+
+
+def _write_rgb_frame(directory: Path, step: int, value: int) -> None:
+    directory.mkdir(parents=True, exist_ok=True)
+    image = np.full((8, 8, 3), fill_value=value, dtype=np.uint8)
+    Image.fromarray(image).save(directory / f"rgb_{step:04d}.png")
+
+
+def test_rlbench_dataset_emits_task_metadata(tmp_path: Path) -> None:
+    task_name = "bimanual_push_box"
+    episode_dir = tmp_path / task_name / "all_variations" / "episodes" / "episode0"
+    episode_dir.mkdir(parents=True, exist_ok=True)
+
+    with (episode_dir / "variation_descriptions.pkl").open("wb") as handle:
+        pickle.dump(["push the box together"], handle)
+    with (episode_dir / "low_dim_obs.pkl").open("wb") as handle:
+        pickle.dump([_obs(0), _obs(1)], handle)
+
+    for camera_name, pixel_value in (("front", 32), ("wrist_left", 96), ("wrist_right", 160)):
+        camera_dir = episode_dir / f"{camera_name}_rgb"
+        _write_rgb_frame(camera_dir, 0, pixel_value)
+        _write_rgb_frame(camera_dir, 1, pixel_value + 1)
+
+    dataset = RLBenchOfflineChunkDataset(
+        dataset_root=tmp_path,
+        tasks=[task_name],
+        episode_indices=[0],
+        resolution=8,
+        chunk_size=2,
+        history_steps=1,
+    )
+
+    item = dataset[0]
+    assert item["task"] == task_name
+    assert item["task_name"] == task_name
+    assert int(item["task_id"]) == -1
+    assert item["texts"] == "push the box together"
+
+    batch = next(iter(DataLoader(dataset, batch_size=1, shuffle=False)))
+    assert batch["task_name"] == [task_name]
+    assert batch["task_id"].tolist() == [-1]
+
+
+def test_sample_weight_from_action_norms_biases_large_actions() -> None:
+    weights = sample_weight_from_action_norms(
+        torch.tensor([0.01, 0.05, 0.20], dtype=torch.float32),
+        min_norm=0.05,
+        power=2.0,
+    )
+
+    assert np.allclose(weights.numpy(), np.asarray([1.0, 1.0, 16.0], dtype=np.float32))

code/VLAarchtests2_code/VLAarchtests/tests/test_rlbench_init_checkpoint.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import torch
+
+from train.run_rlbench_experiment import _load_init_checkpoint
+
+
+class _TinyModule(torch.nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.weight = torch.nn.Parameter(torch.zeros(2, 2))
+        self.bias = torch.nn.Parameter(torch.zeros(2))
+
+
+def test_load_init_checkpoint_skips_shape_mismatch_when_not_strict(tmp_path: Path) -> None:
+    model = _TinyModule()
+    checkpoint_path = tmp_path / "checkpoint.pt"
+    torch.save(
+        {
+            "state_dict": {
+                "weight": torch.ones(3, 3),
+                "bias": torch.full((2,), 5.0),
+            }
+        },
+        checkpoint_path,
+    )
+
+    info = _load_init_checkpoint(model, str(checkpoint_path), strict=False)
+
+    assert info is not None
+    assert info["loaded_keys"] == 1
+    assert info["skipped_shape_mismatch_keys"] == ["weight"]
+    assert torch.allclose(model.bias, torch.full((2,), 5.0))
+    assert torch.allclose(model.weight, torch.zeros(2, 2))

code/VLAarchtests2_code/VLAarchtests/tests/test_rlbench_knn_eval_scene_kwargs.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import torch
+
+from eval.knn_bank_utils import filter_bank_by_action_norm
+from eval.scene_encode_utils import scene_encode_kwargs
+
+
+def test_scene_encode_kwargs_omits_rgbd_for_clip_policy() -> None:
+    batch = {
+        "depths": torch.ones(1, 3, 1, 8, 8),
+        "depth_valid": torch.ones(1, 3, 1, 8, 8),
+        "camera_intrinsics": torch.ones(1, 3, 3, 3),
+        "camera_extrinsics": torch.ones(1, 3, 4, 4),
+    }
+
+    kwargs = scene_encode_kwargs(batch, device=torch.device("cpu"), model_uses_rgbd=False)
+
+    assert kwargs == {}
+
+
+def test_scene_encode_kwargs_includes_rgbd_for_rgbd_policy() -> None:
+    batch = {
+        "depths": torch.ones(1, 3, 1, 8, 8),
+        "depth_valid": torch.ones(1, 3, 1, 8, 8),
+        "camera_intrinsics": torch.ones(1, 3, 3, 3),
+        "camera_extrinsics": torch.ones(1, 3, 4, 4),
+    }
+
+    kwargs = scene_encode_kwargs(batch, device=torch.device("cpu"), model_uses_rgbd=True)
+
+    assert set(kwargs) == {"depths", "depth_valid", "camera_intrinsics", "camera_extrinsics"}
+    assert kwargs["depths"].shape == (1, 3, 1, 8, 8)
+    assert kwargs["camera_extrinsics"].shape == (1, 3, 4, 4)
+
+
+def test_filter_bank_by_action_norm_filters_small_motion_actions() -> None:
+    bank = {
+        "features": torch.arange(9, dtype=torch.float32).view(3, 3),
+        "actions": torch.tensor(
+            [
+                [0.0] * 14,
+                [0.04, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.04, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                [0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            ],
+            dtype=torch.float32,
+        ),
+        "steps": torch.tensor([0, 1, 2], dtype=torch.int64),
+    }
+
+    filtered = filter_bank_by_action_norm(bank, min_action_norm=0.1)
+
+    assert filtered["features"].shape[0] == 1
+    assert filtered["steps"].tolist() == [2]
+
+
+def test_filter_bank_by_action_norm_preserves_bank_when_threshold_removes_everything() -> None:
+    bank = {
+        "features": torch.arange(6, dtype=torch.float32).view(2, 3),
+        "actions": torch.zeros(2, 14, dtype=torch.float32),
+        "steps": torch.tensor([0, 1], dtype=torch.int64),
+    }
+
+    filtered = filter_bank_by_action_norm(bank, min_action_norm=1.0)
+
+    assert filtered["features"].shape[0] == 2
+    assert filtered["steps"].tolist() == [0, 1]

code/VLAarchtests2_code/VLAarchtests/tests/test_rlbench_pickle_bootstrap.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import sys
+
+from sim_rlbench.dataset import _ensure_rlbench_pickle_modules
+
+
+def test_rlbench_pickle_bootstrap_avoids_pyrep(monkeypatch) -> None:
+    for key in list(sys.modules):
+        if key == "pyrep" or key == "rlbench" or key.startswith("rlbench."):
+            monkeypatch.delitem(sys.modules, key, raising=False)
+
+    _ensure_rlbench_pickle_modules()
+
+    assert "rlbench.demo" in sys.modules
+    assert "rlbench.backend.observation" in sys.modules
+    assert "pyrep" not in sys.modules

code/VLAarchtests2_code/VLAarchtests/tests/test_rlbench_task_resolver_aliases.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import importlib
+import sys
+import types
+
+
+def test_task_resolver_maps_overlap_aliases(monkeypatch) -> None:
+    calls: list[tuple[str, bool]] = []
+
+    def fake_task_file_to_task_class(task_name: str, bimanual: bool = False):
+        calls.append((task_name, bimanual))
+        return {"task_name": task_name, "bimanual": bimanual}
+
+    rlbench_pkg = types.ModuleType("rlbench")
+    backend_pkg = types.ModuleType("rlbench.backend")
+    utils_pkg = types.ModuleType("rlbench.backend.utils")
+    utils_pkg.task_file_to_task_class = fake_task_file_to_task_class
+
+    monkeypatch.setitem(sys.modules, "rlbench", rlbench_pkg)
+    monkeypatch.setitem(sys.modules, "rlbench.backend", backend_pkg)
+    monkeypatch.setitem(sys.modules, "rlbench.backend.utils", utils_pkg)
+    sys.modules.pop("sim_rlbench.task_resolver", None)
+
+    resolver = importlib.import_module("sim_rlbench.task_resolver")
+
+    assert resolver.resolve_task_class("bimanual_push_box") == {
+        "task_name": "bimanual_push_box",
+        "bimanual": True,
+    }
+    assert resolver.resolve_task_class("coordinated_push_box") == {
+        "task_name": "bimanual_push_box",
+        "bimanual": True,
+    }
+    assert resolver.resolve_task_class("bimanual_lift_ball") == {
+        "task_name": "bimanual_lift_ball",
+        "bimanual": True,
+    }
+    assert resolver.resolve_task_class("coordinated_lift_ball") == {
+        "task_name": "bimanual_lift_ball",
+        "bimanual": True,
+    }
+    assert resolver.resolve_task_class("bimanual_dual_push_buttons") == {
+        "task_name": "bimanual_dual_push_buttons",
+        "bimanual": True,
+    }
+    assert resolver.resolve_task_class("dual_push_buttons") == {
+        "task_name": "bimanual_dual_push_buttons",
+        "bimanual": True,
+    }
+    assert resolver.resolve_task_class("open_drawer") == {
+        "task_name": "right_open_drawer",
+        "bimanual": True,
+    }
+    assert calls == [
+        ("bimanual_push_box", True),
+        ("bimanual_push_box", True),
+        ("bimanual_lift_ball", True),
+        ("bimanual_lift_ball", True),
+        ("bimanual_dual_push_buttons", True),
+        ("bimanual_dual_push_buttons", True),
+        ("right_open_drawer", True),
+    ]

code/VLAarchtests2_code/VLAarchtests/tests/test_role_loss_permutation.py

@@ -0,0 +1,16 @@
+import torch
+
+from train.losses import permutation_invariant_role_loss
+
+
+def test_role_loss_permutation():
+    logits = torch.tensor(
+        [
+            [[0.1, 4.0, 0.0, -1.0], [0.1, 0.0, 4.0, -1.0]],
+            [[0.1, 0.0, 4.0, -1.0], [0.1, 4.0, 0.0, -1.0]],
+        ],
+        dtype=torch.float32,
+    )
+    loss_original = permutation_invariant_role_loss(logits)
+    loss_swapped = permutation_invariant_role_loss(logits.flip(1))
+    torch.testing.assert_close(loss_original, loss_swapped)

code/VLAarchtests2_code/VLAarchtests/tests/test_rvt_backbone_forward.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import torch
+
+from models.action_decoder import ChunkDecoderConfig
+from models.backbones import FrozenVLBackbone, FrozenVLBackboneConfig
+from models.rvt_backbone import RVTVisualEncoder
+from models.multiview_fusion import MultiViewFusionConfig
+from models.observation_memory import ObservationMemoryConfig
+from models.planner import PlannerConfig
+from models.policy import PolicyConfig
+from models.reveal_head import RevealHeadConfig
+from models.world_model import RevealWMConfig
+from train.trainer import TrainerConfig, build_policy
+
+
+RVT_CHECKPOINT_PATH = Path("/workspace/models/rvt_official/rvt/model_14.pth")
+RVT_MVT_CFG_PATH = Path("/workspace/models/rvt_official/rvt/mvt_cfg.yaml")
+
+pytestmark = pytest.mark.skipif(
+    not (RVT_CHECKPOINT_PATH.exists() and RVT_MVT_CFG_PATH.exists()),
+    reason="RVT official checkpoint assets are not installed on this machine.",
+)
+
+
+def _camera_batch() -> tuple[torch.Tensor, torch.Tensor]:
+    intrinsics = torch.eye(3).view(1, 1, 3, 3).expand(1, 3, 3, 3).clone()
+    intrinsics[:, :, 0, 0] = 30.0
+    intrinsics[:, :, 1, 1] = 30.0
+    intrinsics[:, :, 0, 2] = 16.0
+    intrinsics[:, :, 1, 2] = 16.0
+    extrinsics = torch.eye(4).view(1, 1, 4, 4).expand(1, 3, 4, 4).clone()
+    extrinsics[:, 1, 0, 3] = -0.1
+    extrinsics[:, 2, 0, 3] = 0.1
+    return intrinsics, extrinsics
+
+
+def test_rvt_backbone_emits_five_view_tokens() -> None:
+    backbone = FrozenVLBackbone(
+        FrozenVLBackboneConfig(
+            backbone_type="rvt",
+            hidden_dim=512,
+            max_text_tokens=77,
+            freeze_backbone=True,
+            gradient_checkpointing=False,
+            rvt_point_stride=4,
+            rvt_max_points_per_view=128,
+        )
+    )
+    texts = ["move the box together"]
+    language_tokens = backbone.tokenize_text(texts, device=torch.device("cpu"))
+    text_features = backbone.encode_text(language_tokens["input_ids"], language_tokens["attention_mask"])
+    intrinsics, extrinsics = _camera_batch()
+    tokens = backbone.encode_images(
+        images=torch.rand(1, 3, 3, 32, 32),
+        proprio=torch.rand(1, 32),
+        language_tokens=text_features,
+        depths=torch.rand(1, 3, 1, 32, 32) * 0.3 + 0.2,
+        camera_intrinsics=intrinsics,
+        camera_extrinsics=extrinsics,
+    )
+
+    assert tuple(tokens.shape) == (1, 5, 400, 512)
+
+
+def test_rvt_backbone_uses_fixed_scene_bounds_for_normalization() -> None:
+    encoder = RVTVisualEncoder(
+        checkpoint_path="/workspace/models/rvt_official/rvt/model_14.pth",
+        mvt_cfg_path="/workspace/models/rvt_official/rvt/mvt_cfg.yaml",
+        output_dim=512,
+        input_proprio_dim=32,
+        renderer_device="cpu",
+        point_stride=4,
+        max_points_per_view=128,
+    )
+    points = torch.tensor(
+        [
+            [-0.3, -0.5, 0.6],
+            [0.7, 0.5, 1.6],
+            [0.2, 0.0, 1.1],
+        ],
+        dtype=torch.float32,
+    )
+    normalized = encoder._normalize_world_points(points)
+
+    assert torch.allclose(normalized[0], torch.tensor([-1.0, -1.0, -1.0]))
+    assert torch.allclose(normalized[1], torch.tensor([1.0, 1.0, 1.0]))
+    assert torch.allclose(normalized[2], torch.tensor([0.0, 0.0, 0.0]), atol=1e-6)
+
+
+def test_backbone_only_policy_accepts_rvt_backbone() -> None:
+    intrinsics, extrinsics = _camera_batch()
+    policy = build_policy(
+        PolicyConfig(
+            backbone=FrozenVLBackboneConfig(
+                backbone_type="rvt",
+                hidden_dim=512,
+                max_text_tokens=77,
+                freeze_backbone=True,
+                gradient_checkpointing=False,
+                rvt_point_stride=4,
+                rvt_max_points_per_view=128,
+            ),
+            fusion=MultiViewFusionConfig(
+                hidden_dim=512,
+                num_cameras=5,
+                num_layers=1,
+                num_heads=8,
+                ff_dim=1024,
+                dropout=0.0,
+                proprio_dim=32,
+            ),
+            memory=ObservationMemoryConfig(
+                hidden_dim=512,
+                history_steps=1,
+                num_layers=1,
+                dropout=0.0,
+            ),
+            decoder=ChunkDecoderConfig(
+                hidden_dim=512,
+                num_heads=8,
+                num_layers=1,
+                ff_dim=1024,
+                dropout=0.0,
+                chunk_size=2,
+                action_dim=14,
+                num_candidates=2,
+            ),
+            reveal_head=RevealHeadConfig(hidden_dim=512),
+            world_model=RevealWMConfig(hidden_dim=512),
+            planner=PlannerConfig(hidden_dim=512, num_candidates=2),
+        ),
+        TrainerConfig(
+            policy_type="backbone_only",
+            use_bf16=False,
+            freeze_backbone=True,
+            gradient_checkpointing=False,
+        ),
+    )
+    outputs = policy(
+        images=torch.rand(1, 3, 3, 32, 32),
+        depths=torch.rand(1, 3, 1, 32, 32) * 0.3 + 0.2,
+        camera_intrinsics=intrinsics,
+        camera_extrinsics=extrinsics,
+        proprio=torch.rand(1, 32),
+        texts=["move the box together"],
+    )
+
+    assert tuple(outputs["scene_tokens"].shape) == (1, 2007, 512)
+    assert tuple(outputs["action_mean"].shape) == (1, 2, 14)

code/VLAarchtests2_code/VLAarchtests/tests/test_spatial_memory_occlusion_persistence.py

@@ -0,0 +1,35 @@
+import torch
+
+from models.observation_memory import DualObservationMemory
+
+
+def _slot_scene(hidden_dim: int, slot_idx: int, slot_size: int = 3) -> torch.Tensor:
+    scene = torch.zeros(1, slot_size * 4, hidden_dim)
+    start = slot_idx * slot_size
+    scene[:, start : start + slot_size] = 1.0
+    return scene
+
+
+def test_spatial_memory_occlusion_persistence(tiny_policy_config):
+    config = tiny_policy_config(hidden_dim=16)
+    config.memory.scene_bank_size = 4
+    config.memory.belief_bank_size = 4
+    memory = DualObservationMemory(config.memory)
+    visible = _slot_scene(config.backbone.hidden_dim, 0)
+    occluded = torch.zeros_like(visible)
+    history = torch.stack([visible[0], occluded[0]], dim=0).unsqueeze(0)
+    history_actions = torch.zeros(1, 2, 14)
+
+    during_occlusion = memory(occluded, history_scene_tokens=history, history_actions=history_actions)
+    no_history = memory(
+        occluded,
+        history_scene_tokens=torch.zeros_like(history),
+        history_actions=history_actions,
+    )
+    on_reappearance = memory(visible, history_scene_tokens=history, history_actions=history_actions)
+
+    occluded_delta = (during_occlusion["belief_memory_tokens"] - no_history["belief_memory_tokens"]).norm()
+    reappeared_delta = (on_reappearance["belief_memory_tokens"] - during_occlusion["belief_memory_tokens"]).norm()
+
+    assert occluded_delta > 1e-3
+    assert reappeared_delta > 1e-3

code/VLAarchtests2_code/VLAarchtests/tests/test_summarize_rvt_overlap_branch.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from eval.summarize_rvt_overlap_branch import _branch_summary
+
+
+def test_branch_summary_reports_floor_and_gate(tmp_path) -> None:
+    stage1 = tmp_path / "stage1.json"
+    anyb = tmp_path / "anyb.json"
+    stage1.write_text(
+        """
+{
+  "checkpoint": "/tmp/stage1.pt",
+  "mean_success": 0.2,
+  "tasks": {
+    "bimanual_push_box": {"mean_success": 0.1, "mean_return": 0.1},
+    "bimanual_lift_ball": {"mean_success": 0.2, "mean_return": 0.2},
+    "bimanual_dual_push_buttons": {"mean_success": 0.3, "mean_return": 0.3}
+  }
+}
+""".strip(),
+        encoding="utf-8",
+    )
+    anyb.write_text(
+        """
+{
+  "local_last_complete_step": {
+    "step": 1000,
+    "mean_success": 0.16,
+    "per_task_success": {
+      "coordinated_push_box": 0.0,
+      "coordinated_lift_ball": 0.0,
+      "dual_push_buttons": 0.48
+    }
+  },
+  "public_best_overlap_step": {
+    "step": 60000,
+    "mean_success": 0.6933333333333334,
+    "per_task_success": {
+      "coordinated_push_box": 0.8,
+      "coordinated_lift_ball": 0.32,
+      "dual_push_buttons": 0.96
+    }
+  }
+}
+""".strip(),
+        encoding="utf-8",
+    )
+
+    summary = _branch_summary(stage1, anyb, None)
+
+    assert summary["stage1_frozen"]["mean_success"] == 0.2
+    assert summary["stage2_unfreeze_top2"] is None
+    assert summary["gates"]["stage1_clears_local_floor"] is True
+    assert summary["gates"]["stage2_clears_local_floor"] is False

code/VLAarchtests2_code/VLAarchtests/tests/test_task_conditioned_head_shapes.py

@@ -0,0 +1,31 @@
+import torch
+
+from models.reveal_head import ElasticOcclusionStateHead
+
+
+def test_task_conditioned_head_shapes(tiny_policy_config):
+    config = tiny_policy_config()
+    head = ElasticOcclusionStateHead(config.reveal_head)
+    scene_tokens = torch.rand(3, 12, config.backbone.hidden_dim)
+    memory_tokens = torch.rand(
+        3,
+        config.memory.scene_bank_size + config.memory.belief_bank_size,
+        config.backbone.hidden_dim,
+    )
+    output = head(
+        scene_tokens,
+        memory_tokens=memory_tokens,
+        task_names=["foliage", "bag", "cloth"],
+    )
+    for key in (
+        "opening_quality",
+        "actor_feasibility_score",
+        "gap_width",
+        "hold_quality",
+        "fold_preservation",
+        "lift_too_much_risk",
+    ):
+        assert key in output
+        assert output[key].shape == (3,)
+    assert output["opening_quality_field"].shape[1] == 1
+    assert output["newly_revealed_field"].shape[1] == 1

code/VLAarchtests2_code/VLAarchtests/tests/test_task_metric_monotonicity.py

@@ -0,0 +1,34 @@
+import torch
+
+from models.reveal_head import compute_task_metrics_from_fields
+
+
+def _metrics(access_level: float, disturbance_level: float) -> dict[str, torch.Tensor]:
+    access_field = torch.full((1, 3, 4, 4), access_level)
+    persistence_field = torch.full((1, 1, 4, 4), 0.6)
+    disturbance_field = torch.full((1, 1, 4, 4), disturbance_level)
+    reocclusion_field = torch.full((1, 1, 4, 4), 0.1)
+    visibility_field = torch.full((1, 1, 4, 4), 0.6)
+    clearance_field = torch.full((1, 2, 4, 4), access_level)
+    support_stability_field = torch.full((1, 1, 4, 4), 0.7)
+    uncertainty_field = torch.full((1, 1, 4, 4), 0.2)
+    return compute_task_metrics_from_fields(
+        access_field=access_field,
+        persistence_field=persistence_field,
+        disturbance_field=disturbance_field,
+        reocclusion_field=reocclusion_field,
+        visibility_field=visibility_field,
+        clearance_field=clearance_field,
+        support_stability_field=support_stability_field,
+        uncertainty_field=uncertainty_field,
+    )
+
+
+def test_task_metric_monotonicity():
+    low_open = _metrics(access_level=0.1, disturbance_level=0.2)
+    high_open = _metrics(access_level=0.9, disturbance_level=0.2)
+    over_lift = _metrics(access_level=0.9, disturbance_level=0.8)
+
+    assert high_open["mouth_aperture"] > low_open["mouth_aperture"]
+    assert high_open["actor_feasibility_score"] > low_open["actor_feasibility_score"]
+    assert over_lift["fold_preservation"] < high_open["fold_preservation"]

code/VLAarchtests2_code/VLAarchtests/tests/test_task_routed_model_eval.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import torch
+
+import eval.run_reveal_benchmark as benchmark
+
+
+def _record(spec: dict[str, object], success: float) -> dict[str, object]:
+    return {
+        "proxy_name": str(spec["proxy_name"]),
+        "task_name": str(spec["task_name"]),
+        "task_id": int(spec["task_id"]),
+        "stress_slice": str(spec.get("stress_slice", "nominal")),
+        "difficulty_bin": str(spec.get("difficulty_bin", "medium")),
+        "seed": int(spec["seed"]),
+        "episode_index": int(spec.get("episode_index", 0)),
+        "controller": "model",
+        "resolved_task_name": str(spec["task_name"]),
+        "success": float(success),
+        "visibility_integral": 1.0,
+        "corridor_availability": 1.0,
+        "reocclusion_rate": 0.0,
+        "disturbance_cost": 0.1,
+        "premature_retrieve_rate": 0.0,
+        "reocclusion_after_reveal": 0.0,
+        "planner_regret": 0.0,
+        "step_trace": [],
+        "chosen_candidate_families": [],
+        "episode_metadata": {},
+    }
+
+
+def test_parse_task_routed_models_rejects_duplicates() -> None:
+    with pytest.raises(ValueError, match="Duplicate routed model key"):
+        benchmark._parse_task_routed_models(["bag=/tmp/a.pt", "bag=/tmp/b.pt"])
+
+
+def test_resolve_task_routed_key_precedence() -> None:
+    routes = {
+        "bag": "/tmp/task.pt",
+        "bag_proxy": "/tmp/proxy.pt",
+        "3": "/tmp/id.pt",
+        "default": "/tmp/default.pt",
+    }
+    assert benchmark._resolve_task_routed_key({"task_name": "bag", "proxy_name": "bag_proxy", "task_id": 3}, routes) == "bag"
+    assert benchmark._resolve_task_routed_key({"task_name": "other", "proxy_name": "bag_proxy", "task_id": 3}, routes) == "bag_proxy"
+    assert benchmark._resolve_task_routed_key({"task_name": "other", "proxy_name": "other_proxy", "task_id": 3}, routes) == "3"
+    assert benchmark._resolve_task_routed_key({"task_name": "other", "proxy_name": "other_proxy", "task_id": 8}, routes) == "default"
+
+
+def test_evaluate_task_routed_models_combines_records(monkeypatch: pytest.MonkeyPatch) -> None:
+    loaded_paths: list[str] = []
+    eval_calls: list[tuple[int, tuple[str, ...]]] = []
+
+    def fake_load_model(checkpoint_path: str | Path, device: torch.device):
+        loaded_paths.append(str(checkpoint_path))
+        checkpoint_name = Path(str(checkpoint_path)).name
+        if checkpoint_name == "shared.pt":
+            resolution = 104
+        elif checkpoint_name == "iter6.pt":
+            resolution = 96
+        else:
+            resolution = 112
+        return object(), {"data_resolution": resolution, "_shape_mismatch_keys": []}
+
+    def fake_evaluate_model(
+        model,
+        device,
+        proxies,
+        episodes,
+        resolution,
+        ablation=None,
+        chunk_commit_steps=None,
+        episode_specs=None,
+        controller="model",
+        controller_options=None,
+    ):
+        del model, device, proxies, episodes, ablation, chunk_commit_steps, controller, controller_options
+        assert episode_specs is not None
+        eval_calls.append((resolution, tuple(str(spec["task_name"]) for spec in episode_specs)))
+        records = []
+        for spec in episode_specs:
+            success = 0.9 if str(spec["task_name"]) == "foliage" else 0.5
+            records.append(_record(spec, success))
+        return None, records
+
+    monkeypatch.setattr(benchmark, "load_model", fake_load_model)
+    monkeypatch.setattr(benchmark, "evaluate_model", fake_evaluate_model)
+
+    specs = [
+        {"proxy_name": "foliage_proxy", "task_name": "foliage", "task_id": 0, "seed": 1},
+        {"proxy_name": "bag_proxy", "task_name": "bag", "task_id": 1, "seed": 2},
+        {"proxy_name": "cloth_proxy", "task_name": "cloth", "task_id": 2, "seed": 3},
+    ]
+    metrics, records, route_details = benchmark.evaluate_task_routed_models(
+        routed_models={
+            "foliage": "/tmp/iter6.pt",
+            "bag": "/tmp/shared.pt",
+            "cloth": "/tmp/shared.pt",
+        },
+        device=torch.device("cpu"),
+        proxies=["foliage_proxy", "bag_proxy", "cloth_proxy"],
+        episodes=None,
+        resolution=None,
+        episode_specs=specs,
+    )
+
+    assert sorted(loaded_paths) == ["/tmp/iter6.pt", "/tmp/shared.pt"]
+    assert sorted(eval_calls) == [(96, ("foliage",)), (104, ("bag", "cloth"))]
+    assert metrics.per_task_success == {"bag": 0.5, "cloth": 0.5, "foliage": 0.9}
+    assert pytest.approx(metrics.mean_success, rel=1e-6) == (0.5 + 0.5 + 0.9) / 3.0
+    assert sorted(record["model_route_key"] for record in records) == ["bag", "cloth", "foliage"]
+    assert route_details["bag"]["episodes"] == 1
+    assert route_details["cloth"]["episodes"] == 1
+    assert route_details["foliage"]["resolution"] == 96

code/VLAarchtests2_code/VLAarchtests/tests/test_teacher_audit.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+from sim_reveal.procedural_envs import available_proxy_names, make_proxy_env
+
+
+def _mean_utility(proxy_name: str, baseline_name: str, seeds: range) -> float:
+    utilities = []
+    for seed in seeds:
+        env = make_proxy_env(proxy_name=proxy_name, resolution=32, seed=seed, rollout_horizon=4)
+        _, _ = env.reset(seed=seed)
+        chunk = env.baseline_action_chunk(baseline_name, chunk_horizon=4)
+        outcome = env.evaluate_action_chunk(chunk, rollout_horizon=4)
+        utility = float(outcome["retrieval_success"]) - float(outcome["final_disturbance_cost"]) - float(outcome["reocclusion_rate"])
+        utilities.append(utility)
+    return float(np.mean(utilities))
+
+
+def test_teacher_audit():
+    seeds = range(5)
+    for proxy_name in available_proxy_names():
+        teacher_utility = _mean_utility(proxy_name, "teacher", seeds)
+        assert teacher_utility >= _mean_utility(proxy_name, "random", seeds)
+        assert teacher_utility >= _mean_utility(proxy_name, "retrieve_only", seeds)
+        assert teacher_utility >= _mean_utility(proxy_name, "reveal_only", seeds)
+        assert teacher_utility >= _mean_utility(proxy_name, "no_hold", seeds)

code/VLAarchtests2_code/VLAarchtests/tests/test_text_routing_only_used_as_fallback.py

@@ -0,0 +1,52 @@
+from train.trainer import build_policy
+
+
+def test_text_routing_only_used_as_fallback(tiny_policy_config, tiny_trainer_config, tiny_batch):
+    config = tiny_policy_config()
+    batch = tiny_batch(chunk_size=config.decoder.chunk_size)
+    batch["texts"] = ["foliage canopy leaves snail"] * batch["images"].shape[0]
+    policy = build_policy(config, tiny_trainer_config(policy_type="elastic_reveal"))
+    policy.eval()
+
+    fallback_output = policy(
+        images=batch["images"],
+        depths=batch["depths"],
+        depth_valid=batch["depth_valid"],
+        camera_intrinsics=batch["camera_intrinsics"],
+        camera_extrinsics=batch["camera_extrinsics"],
+        proprio=batch["proprio"],
+        texts=batch["texts"],
+        history_images=batch["history_images"],
+        history_depths=batch["history_depths"],
+        history_depth_valid=batch["history_depth_valid"],
+        history_camera_intrinsics=batch["history_camera_intrinsics"],
+        history_camera_extrinsics=batch["history_camera_extrinsics"],
+        history_camera_valid_mask=batch["history_camera_valid_mask"],
+        history_proprio=batch["history_proprio"],
+        history_actions=batch["history_actions"],
+        plan=False,
+    )
+    metadata_output = policy(
+        images=batch["images"],
+        depths=batch["depths"],
+        depth_valid=batch["depth_valid"],
+        camera_intrinsics=batch["camera_intrinsics"],
+        camera_extrinsics=batch["camera_extrinsics"],
+        proprio=batch["proprio"],
+        texts=batch["texts"],
+        task_names=["bag"] * batch["images"].shape[0],
+        task_ids=batch["task_id"],
+        history_images=batch["history_images"],
+        history_depths=batch["history_depths"],
+        history_depth_valid=batch["history_depth_valid"],
+        history_camera_intrinsics=batch["history_camera_intrinsics"],
+        history_camera_extrinsics=batch["history_camera_extrinsics"],
+        history_camera_valid_mask=batch["history_camera_valid_mask"],
+        history_proprio=batch["history_proprio"],
+        history_actions=batch["history_actions"],
+        plan=False,
+    )
+
+    assert fallback_output["task_names"] == ["foliage"] * batch["images"].shape[0]
+    assert metadata_output["task_names"] == ["bag"] * batch["images"].shape[0]
+    assert fallback_output["proposal_mode_names"][0] != metadata_output["proposal_mode_names"][0]

code/VLAarchtests2_code/VLAarchtests/tests/test_world_model_field_consistency.py

@@ -0,0 +1,16 @@
+import torch
+
+from models.world_model import ElasticOcclusionWorldModel
+
+
+def test_world_model_field_consistency(tiny_policy_config, tiny_state):
+    config = tiny_policy_config()
+    config.world_model.rollout_mode = "null_rollout"
+    model = ElasticOcclusionWorldModel(config.world_model)
+    state = tiny_state(field_size=config.reveal_head.field_size)
+    scene_tokens = torch.rand(2, 12, config.backbone.hidden_dim)
+    action_chunk = torch.rand(2, config.decoder.chunk_size, 14)
+    output = model(scene_tokens=scene_tokens, interaction_state=state, action_chunk=action_chunk)
+    target = state["clearance_field"].unsqueeze(1).expand(-1, config.decoder.chunk_size, -1, -1, -1)
+    mae = (output["clearance_field"] - target).abs().mean()
+    assert float(mae) < 1e-6

code/VLAarchtests2_code/VLAarchtests/tests/test_world_model_identity_rollout.py

@@ -0,0 +1,17 @@
+import torch
+
+from models.world_model import ElasticOcclusionWorldModel
+
+
+def test_world_model_identity_rollout(tiny_policy_config, tiny_state):
+    config = tiny_policy_config()
+    config.world_model.rollout_mode = "identity_rollout"
+    model = ElasticOcclusionWorldModel(config.world_model)
+    state = tiny_state(field_size=config.reveal_head.field_size)
+    scene_tokens = torch.rand(2, 12, config.backbone.hidden_dim)
+    action_chunk = torch.rand(2, config.decoder.chunk_size, 14)
+    output = model(scene_tokens=scene_tokens, interaction_state=state, action_chunk=action_chunk)
+    expected_roles = state["arm_role_logits"].unsqueeze(1).expand(-1, config.decoder.chunk_size, -1, -1)
+    assert torch.allclose(output["arm_role_logits"], expected_roles)
+    expected_visibility = state["visibility_field"].unsqueeze(1).expand(-1, config.decoder.chunk_size, -1, -1, -1)
+    assert torch.allclose(output["visibility_field"], expected_visibility)

code/VLAarchtests2_code/VLAarchtests/tests/test_world_model_null_rollout.py

@@ -0,0 +1,17 @@
+import torch
+
+from models.world_model import ElasticOcclusionWorldModel
+
+
+def test_world_model_null_rollout(tiny_policy_config, tiny_state):
+    config = tiny_policy_config()
+    config.world_model.rollout_mode = "null_rollout"
+    model = ElasticOcclusionWorldModel(config.world_model)
+    state = tiny_state(field_size=config.reveal_head.field_size)
+    scene_tokens = torch.rand(2, 12, config.backbone.hidden_dim)
+    action_chunk = torch.rand(2, config.decoder.chunk_size, 14)
+    output = model(scene_tokens=scene_tokens, interaction_state=state, action_chunk=action_chunk)
+    expected = state["target_belief_field"].unsqueeze(1).expand(-1, config.decoder.chunk_size, -1, -1, -1)
+    assert torch.allclose(output["target_belief_field"], expected)
+    expected_support = state["support_mode_logits"].unsqueeze(1).expand(-1, config.decoder.chunk_size, -1)
+    assert torch.allclose(output["support_mode_logits"], expected_support)

code/VLAarchtests2_code/VLAarchtests/tests/test_world_model_task_adapter.py

@@ -0,0 +1,32 @@
+import torch
+
+from models.world_model import ElasticOcclusionWorldModel
+
+
+def test_world_model_task_adapter(tiny_policy_config, tiny_state):
+    config = tiny_policy_config()
+    config.world_model.rollout_mode = "spatial_rollout"
+    model = ElasticOcclusionWorldModel(config.world_model)
+    state = tiny_state(field_size=config.reveal_head.field_size)
+    state["scene_memory_tokens"] = torch.rand(1, config.memory.scene_bank_size, config.backbone.hidden_dim)
+    state["belief_memory_tokens"] = torch.rand(1, config.memory.belief_bank_size, config.backbone.hidden_dim)
+    state = {key: value[:1] for key, value in state.items()}
+    scene_tokens = torch.rand(1, 12, config.backbone.hidden_dim)
+    action_chunk = torch.zeros(1, config.decoder.chunk_size, 14)
+    foliage = model(
+        scene_tokens=scene_tokens,
+        interaction_state=state,
+        action_chunk=action_chunk,
+        scene_memory_tokens=state["scene_memory_tokens"],
+        belief_memory_tokens=state["belief_memory_tokens"],
+        task_names=["foliage"],
+    )
+    bag = model(
+        scene_tokens=scene_tokens,
+        interaction_state=state,
+        action_chunk=action_chunk,
+        scene_memory_tokens=state["scene_memory_tokens"],
+        belief_memory_tokens=state["belief_memory_tokens"],
+        task_names=["bag"],
+    )
+    assert not torch.allclose(foliage["support_mode_logits"], bag["support_mode_logits"])

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_ik_c1_s1.log

@@ -0,0 +1,1241 @@
+/workspace/VLAarchtests/code/reveal_vla_bimanual/models/multiview_fusion.py:65: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.norm_first was True
+  self.cross_view_transformer = nn.TransformerEncoder(
+WARNING:root:not sure how _robot_shapes are used is used.
+[task] bimanual_dual_push_buttons: mean_success=0.000 mean_return=0.000
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "ik",
+  "delta_scale": 1.0,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}
+[CoppeliaSim:loadinfo]   done.

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_ik_c1_s1/rollout_eval.json

@@ -0,0 +1,1236 @@
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "ik",
+  "delta_scale": 1.0,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_ik_c1_s1/rollout_eval.md

@@ -0,0 +1,14 @@
+# RLBench Rollout Eval
+
+- Checkpoint: `/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt`
+- Plan requested: `False`
+- Plan applied: `False`
+- Support-mode conditioning: `True`
+- Task conditioning: `True`
+- Geometry enabled: `True`
+- World-model mode: `checkpoint_default`
+- Mean success: `0.000`
+
+## Per-task
+
+- `bimanual_dual_push_buttons`: mean_success=0.000, returns=[0.0, 0.0, 0.0, 0.0, 0.0]

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_ik_c1_s1/rollout_eval.partial.json

@@ -0,0 +1,1236 @@
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "ik",
+  "delta_scale": 1.0,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s05.log

@@ -0,0 +1,1241 @@
+/workspace/VLAarchtests/code/reveal_vla_bimanual/models/multiview_fusion.py:65: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.norm_first was True
+  self.cross_view_transformer = nn.TransformerEncoder(
+WARNING:root:not sure how _robot_shapes are used is used.
+[task] bimanual_dual_push_buttons: mean_success=0.000 mean_return=0.000
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "planning",
+  "delta_scale": 0.5,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        25,
+        25,
+        25,
+        25,
+        25
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}
+[CoppeliaSim:loadinfo]   done.

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s05/rollout_eval.json

@@ -0,0 +1,1236 @@
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "planning",
+  "delta_scale": 0.5,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        25,
+        25,
+        25,
+        25,
+        25
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s05/rollout_eval.md

@@ -0,0 +1,14 @@
+# RLBench Rollout Eval
+
+- Checkpoint: `/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt`
+- Plan requested: `False`
+- Plan applied: `False`
+- Support-mode conditioning: `True`
+- Task conditioning: `True`
+- Geometry enabled: `True`
+- World-model mode: `checkpoint_default`
+- Mean success: `0.000`
+
+## Per-task
+
+- `bimanual_dual_push_buttons`: mean_success=0.000, returns=[0.0, 0.0, 0.0, 0.0, 0.0]

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s05/rollout_eval.partial.json

@@ -0,0 +1,1236 @@
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "planning",
+  "delta_scale": 0.5,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        25,
+        25,
+        25,
+        25,
+        25
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 1,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 25,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s1.log

@@ -0,0 +1,1241 @@
+/workspace/VLAarchtests/code/reveal_vla_bimanual/models/multiview_fusion.py:65: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.norm_first was True
+  self.cross_view_transformer = nn.TransformerEncoder(
+WARNING:root:not sure how _robot_shapes are used is used.
+[task] bimanual_dual_push_buttons: mean_success=0.000 mean_return=0.000
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "planning",
+  "delta_scale": 1.0,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}
+[CoppeliaSim:loadinfo]   done.

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s1/rollout_eval.json

@@ -0,0 +1,1236 @@
+{
+  "checkpoint": "/workspace/outputs/rlbench_true_baselines/rlbench_subset3_backbone_only_clip_100demo_fair_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "planning",
+  "delta_scale": 1.0,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/knn_top1_planning.log

@@ -0,0 +1,22 @@
+/workspace/VLAarchtests/code/reveal_vla_bimanual/models/multiview_fusion.py:65: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.norm_first was True
+  self.cross_view_transformer = nn.TransformerEncoder(
+Traceback (most recent call last):
+  File "/workspace/envs/rlbench/lib/python3.10/runpy.py", line 196, in _run_module_as_main
+    return _run_code(code, main_globals, None,
+  File "/workspace/envs/rlbench/lib/python3.10/runpy.py", line 86, in _run_code
+    exec(code, run_globals)
+  File "/workspace/VLAarchtests/code/reveal_vla_bimanual/eval/run_rlbench_knn_eval.py", line 361, in <module>
+    main()
+  File "/workspace/VLAarchtests/code/reveal_vla_bimanual/eval/run_rlbench_knn_eval.py", line 220, in main
+    bank = _encode_bank(
+  File "/workspace/VLAarchtests/code/reveal_vla_bimanual/eval/run_rlbench_knn_eval.py", line 63, in _encode_bank
+    scene_tokens = model.encode_scene(
+  File "/workspace/VLAarchtests/code/reveal_vla_bimanual/models/policy.py", line 113, in encode_scene
+    return self.fusion(image_tokens=image_tokens, proprio=proprio, language_tokens=text_tokens)
+  File "/workspace/envs/rlbench/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1779, in _wrapped_call_impl
+    return self._call_impl(*args, **kwargs)
+  File "/workspace/envs/rlbench/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1790, in _call_impl
+    return forward_call(*args, **kwargs)
+  File "/workspace/VLAarchtests/code/reveal_vla_bimanual/models/multiview_fusion.py", line 90, in forward
+    batch_size, num_views, num_tokens, hidden_dim = image_tokens.shape
+AttributeError: 'dict' object has no attribute 'shape'

code/VLAarchtests2_code/reports/dual_push_anchor_sweeps_20260330/sweep_summary.json

@@ -0,0 +1,24 @@
+{
+  "direct_planning_c1_s1": {
+    "returncode": 0,
+    "log": "/workspace/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s1.log",
+    "mean_success": 0.0,
+    "mean_return": 0.0
+  },
+  "direct_ik_c1_s1": {
+    "returncode": 0,
+    "log": "/workspace/reports/dual_push_anchor_sweeps_20260330/direct_ik_c1_s1.log",
+    "mean_success": 0.0,
+    "mean_return": 0.0
+  },
+  "direct_planning_c1_s05": {
+    "returncode": 0,
+    "log": "/workspace/reports/dual_push_anchor_sweeps_20260330/direct_planning_c1_s05.log",
+    "mean_success": 0.0,
+    "mean_return": 0.0
+  },
+  "knn_top1_planning": {
+    "returncode": 1,
+    "log": "/workspace/reports/dual_push_anchor_sweeps_20260330/knn_top1_planning.log"
+  }
+}

code/VLAarchtests2_code/reports/dual_push_nonzero_branch_20260330/controller_sweep/ik_c1/rollout_eval.json

@@ -0,0 +1,1236 @@
+{
+  "checkpoint": "/workspace/outputs/rlbench_dual_push/rlbench_dual_push_backbone_only_clip_finetune_seed17/checkpoint_best.pt",
+  "plan_requested": false,
+  "plan_applied": false,
+  "planner_mode": "trainable",
+  "support_mode_conditioning": true,
+  "task_conditioning": true,
+  "geometry_enabled": true,
+  "world_model_mode": "checkpoint_default",
+  "episodes_per_task": 5,
+  "episode_length": 25,
+  "resolution": 256,
+  "reset_retries": 20,
+  "arm_mode": "ik",
+  "delta_scale": 1.0,
+  "cameras": [
+    "front",
+    "wrist_left",
+    "wrist_right"
+  ],
+  "tasks": {
+    "bimanual_dual_push_buttons": {
+      "task_class": "DualPushButtons",
+      "successes": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "returns": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "path_recoveries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "noop_fallbacks": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "reset_retries": [
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "episode_traces": [
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        },
+        {
+          "language_goal": "push the olive and the orange buttons",
+          "steps": [
+            {
+              "timestep": 0,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 1,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 2,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 3,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 4,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 5,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 6,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 7,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 8,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 9,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 10,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 11,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 12,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 13,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 14,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 15,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 16,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 17,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 18,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 19,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 20,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 21,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 22,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 23,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            },
+            {
+              "timestep": 24,
+              "chosen_macro_mode": null,
+              "planner_scores": null,
+              "predicted_reocclusion": null,
+              "support_mode_conditioning": true,
+              "path_recoveries": 0,
+              "noop_fallbacks": 0
+            }
+          ],
+          "success": 0.0,
+          "return": 0.0,
+          "path_recoveries": 0,
+          "noop_fallbacks": 0
+        }
+      ],
+      "mean_success": 0.0,
+      "mean_return": 0.0
+    }
+  },
+  "mean_success": 0.0
+}