Release original E5+C3 training and evaluation source, configs, results and loss curves

DEPENDENCIES.json

@@ -0,0 +1,23 @@
+{
+  "dataset": {
+    "frames": 549787,
+    "repo_id": "TianxingChen/RoboTwin2.0",
+    "revision": "981c92aa34d8f94d4cff47e0d5bc2f7d4e0af042",
+    "scope": "50 clean episodes/task across50tasks, original train+val partitions both included in original all-clean training. No held-out validation, seed7, normalization fixed.",
+    "trajectories": 2500
+  },
+  "models": {
+    "base": {
+      "repo_id": "robbyant/lingbot-vla-v2-6b",
+      "revision": "11c703bf6a5c1f45b3b69168482da11fdbba53d7"
+    },
+    "depth_teacher": {
+      "repo_id": "Ruicheng/moge-2-vitb-normal",
+      "revision": "ca5f0e07ff01d3e5a364c1d954ed12ee1814b368"
+    },
+    "tokenizer": {
+      "repo_id": "Qwen/Qwen3-VL-4B-Instruct",
+      "revision": "ebb281ec70b05090aa6165b016eac8ec08e71b17"
+    }
+  }
+}

EVALUATION.md

@@ -0,0 +1,82 @@
+# Actual evaluation method and results
+
+The historical benchmark is `robotwin-eval-subset-v2-seen-unseen`, fixed subset commit
+`b5abe512dafd400736c6dca5905f2fd262dd9029`: 50 tasks × 10 clean/seen + 10 randomized/unseen
+episodes, 1000 episodes per model. The same 1000 episode IDs and initial RGB/public-state
+hashes match across endpoints. Accepted policy failures are included; infrastructure retries
+are excluded. Evaluation uses unseen instructions, not unseen-instruction training.
+All tasks are present in the all-clean training set. Seen/unseen refers to instruction pools;
+clean/seen versus randomized/unseen changes both visual conditions and instruction pools.
+These results concern the original fixed-table runs, not later low-table adaptations.
+
+| Model | Clean / seen | Randomized / unseen | Overall |
+|---|---:|---:|---:|
+| ep2 | 381/500 (76.2%) | 204/500 (40.8%) | 585/1000 (58.5%) |
+| ep6 | 416/500 (83.2%) | 178/500 (35.6%) | 594/1000 (59.4%) |
+
+Per-task counts, completed/planned counts, success rates, worker counts and measured episode
+wall times are in `RESULTS.json`. Wall times are specific to the actual distributed setup,
+not hardware-independent model latency. These are historical results, not current service status.
+
+Model inference used F32 weights/main path, eager action attention, compile=false, tf32=false,
+autocast=false. Official FA2 vision casts FP32 Q/K/V to BF16 internally and restores output dtype.
+E5 causal history is reset per episode/session, uses only confirmed executed command prefixes,
+and prior public drive-target state observations. It is not measured-qpos history.
+
+The checkpoint requires custom runtime loading, the original normalization, three camera inputs,
+14-dimensional execution commands and baseline dependencies. Core runtime source is preserved
+from original training archives. `scripts/e5_rollout_history.py` implements the causal history contract.
+Use `HARDWARE.md` for actual inference/rendering machines and precision boundaries.
+
+Exact original server, transport, renderer worker and subset verifier source from both evaluations is included and hashed in `SOURCE_MANIFEST.json`.
+
+Exact end-to-end rollout reproduction still requires the fixed subset, compatible RoboTwin
+simulation assets and matching server/renderer integration. No generic upstream evaluation
+script is represented as the exact 1000-episode harness. No new rollout was run for this release.
+原始记录保存在本地。
+
+## Portable entry
+
+Download the selected public checkpoint, including `training_config.yaml`, to `checkpoints/ep2`
+or `checkpoints/ep6`. The release identity adapter verifies all six original shard hashes,
+the index, sanitized model/training config and normalization before loading. It replaces
+only checks tied to private training records. The loader now reads `training_config.yaml`
+beside the shards. `SOURCE_MANIFEST.json` lists these changes and retains both original
+registry hashes. The earlier training-archive rollout-history version is retained under
+`training_reference/`; the active version is the exact source used by both evaluations.
+
+Install the CUDA inference dependencies; keep Qwen3-VL under
+`checkpoints/dependencies/Qwen3-VL-4B-Instruct`. Place compatible RoboTwin source/assets in
+`third_party/RoboTwin`. Original warmup requires the clean adjust_bottle episode0 HDF5 under
+`data/raw/adjust_bottle/aloha-agilex_clean_50/data/episode0.hdf5`.
+The fixed subset must be a checksummed Git checkout. A public mirror is
+[ar-mine/robotwin-eval-subset-v2-seen-unseen](https://huggingface.co/datasets/ar-mine/robotwin-eval-subset-v2-seen-unseen/tree/73277c2022be224d3afb195b503a3cff56ded46d),
+at HF revision `73277c2022be224d3afb195b503a3cff56ded46d`. Its package SHA256SUMS is byte-identical
+to the original benchmark (SHA256 `a8a41f7c5162732cce287e77628840bf754f631825d3a6a343d51c648f932eb9`).
+The wrapper accepts either the original Git commit above or this fixed public mirror commit,
+verifies the exact checksum-file hash and all package files, and records the actual checkout
+commit used. Set `SUBSET_ROOT` to `benchmarks/robotwin_eval_subset_v2_seen_unseen` inside that
+checkout and `RUN_DIR` to a fresh local result directory. Configure the
+already-established transport so the renderer can reach the inference server on localhost
+port 9340. The wrapper creates no SSH tunnels, scheduler allocations or remote jobs.
+
+On the inference machine (A100), after selecting its GPU through `CUDA_VISIBLE_DEVICES`:
+
+```bash
+python scripts/release_eval.py server --epoch ep6 --output "$RUN_DIR/server" --port 9340 --run
+```
+
+On the renderer (RTX 5090), set `EVAL_GPU_UUID` and `CUDA_VISIBLE_DEVICES` to the same allocated
+render GPU UUID. Execute an episode from the fixed subset:
+
+```bash
+python scripts/release_eval.py episode --epoch ep6 --subset "$SUBSET_ROOT"   --task adjust_bottle --setting clean --index 0 --output "$RUN_DIR/adjust_bottle_clean_0"   --port 9340 --run
+```
+
+Omit `--run` to validate/print a plan without starting a GPU process or service. For epoch2
+choose `--epoch ep2` on both sides. The original worker applies per-episode seeds, RT rendering,
+confirmed-action and public-state history, session reset and strict server-identity checks.
+The wrapper runs one episode at a time; full1000 orchestration, resumability and infrastructure
+retry accounting remain the executor's responsibility. Do not compare an incomplete run with
+the historical full1000 table. Portable entries received CPU validation only; target-GPU
+loading, the two-episode causal-history smoke, and full benchmark reproduction remain pending.

HARDWARE.md

@@ -0,0 +1,19 @@
+# Hardware and version boundaries
+
+Actual training allocations:
+
+- ep2: 1 node(s), 4 × NVIDIA A100-SXM4-40GB, 40960 MiB per GPU. Scheduler requested 64 CPUs and 440 GB RAM per node; this is not measured usage. CPU model: not captured in preserved allocation/binding record.
+- ep6: 2 node(s), 8 × NVIDIA A100-SXM4-40GB, 40960 MiB per GPU. Scheduler requested 64 CPUs and 440 GB RAM per node; this is not measured usage. CPU model: not captured in preserved allocation/binding record.
+
+Actual evaluation inference used NVIDIA A100-SXM4-40GB (42406903808 reported bytes),
+PyTorch 2.8.0+cu128, CUDA 12.8, one model replica per reported server; six max clients.
+Episode workers: epoch2 4/6 across recorded batches; epoch6 6. Rendering used RTX 5090 32GB.
+
+A pre-evaluation workstation snapshot dated 2026-09-18 reports Intel i9-12900KF,
+24 logical CPUs, 62 GiB RAM, RTX 5090 32607 MiB, Ubuntu 22.04.5 and driver 580.178.04.
+That older snapshot is not proof that the driver/CPU/RAM was rechecked at every rollout.
+Training CPU model, actual memory usage and inference-server CPU/RAM are not recovered
+in the supplied facts. Do not substitute hardware from later experiments.
+
+No hardware was exercised for this release; these statements describe historical runs.
+原始记录保存在本地。

README.md

@@ -0,0 +1,39 @@
+---
+tags:
+- robotics
+- lingbot-vla
+---
+# E5+C3 original training code and evaluation documentation
+
+Public release, 2026-10-25 (Asia/Singapore). This Hugging Face dataset hosts a **Git source
+repository**, cloneable with `git clone https://huggingface.co/datasets/ar-mine/e5-c3-code`.
+It is not a training dataset or a generic AutoModel implementation.
+
+[Epoch2 weights](https://huggingface.co/ar-mine/lingbot-vla-v2-6b-e5-c3-epoch2-step17180) ·
+[Epoch6 weights](https://huggingface.co/ar-mine/lingbot-vla-v2-6b-e5-c3-epoch6-step17178) ·
+[Training method and reproduction](TRAINING.md) · [Evaluation method](EVALUATION.md) ·
+[Hardware](HARDWARE.md) · [Full results](RESULTS.json).
+
+| Model | Clean / seen | Randomized / unseen | Overall |
+|---|---:|---:|---:|
+| ep2 | 381/500 (76.2%) | 204/500 (40.8%) | 585/1000 (58.5%) |
+| ep6 | 416/500 (83.2%) | 178/500 (35.6%) | 594/1000 (59.4%) |
+
+These are completed historical evaluations; the release task ran no new rollouts or training.
+Epoch2 and epoch6 differ in global batch (64/192), LR (1e-4/1.5e-4), GPU count (4/8)
+and epoch count. They are not a pure epoch ablation.
+Clean/seen versus randomized/unseen also changes the instruction pool, so it is not a pure
+visual randomization effect. All 50 tasks appear in training; seen/unseen describes instruction
+vocabulary/template pools, not unseen tasks. These are the original fixed-table runs, not later
+low-table adaptation or interpolation experiments.
+
+The actual original training archives supply the shared runtime, training entry, E5 history
+logic, C3 augmentation, normalization and configs. Selected shared files are byte-identical
+between endpoints before the documented portable path changes. `SOURCE_MANIFEST.json`
+records original/export SHA256 values, original archive SHA256 values and portable edits.
+Original archive contents, machine-specific mappings and records remain local: 原始记录保存在本地。
+
+Upstream licenses are preserved in `third_party/lingbot-vla-v2/LICENSE` and nested dependency
+LICENSE files. Original upstream illustrations/loss plots are omitted; they are not these runs'
+curves. Deployment allocation scripts and private machine layouts are not required by the
+portable training entry. See the explicit remaining reproduction limits in the method documents.

RESULTS.json

@@ -0,0 +1,1237 @@
+{
+  "dataset": {
+    "frames": 549787,
+    "repo_id": "TianxingChen/RoboTwin2.0",
+    "revision": "981c92aa34d8f94d4cff47e0d5bc2f7d4e0af042",
+    "scope": "50 clean episodes/task across50tasks, original train+val partitions both included in original all-clean training. No held-out validation, seed7, normalization fixed.",
+    "trajectories": 2500
+  },
+  "date": "2026-10-25",
+  "dependency_models": {
+    "base": {
+      "repo_id": "robbyant/lingbot-vla-v2-6b",
+      "revision": "11c703bf6a5c1f45b3b69168482da11fdbba53d7"
+    },
+    "depth_teacher": {
+      "repo_id": "Ruicheng/moge-2-vitb-normal",
+      "revision": "ca5f0e07ff01d3e5a364c1d954ed12ee1814b368"
+    },
+    "tokenizer": {
+      "repo_id": "Qwen/Qwen3-VL-4B-Instruct",
+      "revision": "ebb281ec70b05090aa6165b016eac8ec08e71b17"
+    }
+  },
+  "eval_note": "Both original benchmarks completed. Compile/TF32/autocast disabled, eager action attention; official FA2 vision internally casts QKV to BF16. Not pure all-FP32 operations.",
+  "models": {
+    "ep2": {
+      "evaluation": {
+        "by_task": {
+          "adjust_bottle": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 7
+            }
+          },
+          "beat_block_hammer": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "blocks_ranking_rgb": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "blocks_ranking_size": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "click_alarmclock": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 9
+            }
+          },
+          "click_bell": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "dump_bin_bigbin": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 10
+            }
+          },
+          "grab_roller": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "handover_block": {
+            "clean": {
+              "episodes": 10,
+              "successes": 4
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "handover_mic": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "hanging_mug": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "lift_pot": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "move_can_pot": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "move_pillbottle_pad": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "move_playingcard_away": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 7
+            }
+          },
+          "move_stapler_pad": {
+            "clean": {
+              "episodes": 10,
+              "successes": 2
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "open_laptop": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "open_microwave": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "pick_diverse_bottles": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "pick_dual_bottles": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "place_a2b_left": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_a2b_right": {
+            "clean": {
+              "episodes": 10,
+              "successes": 6
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_bread_basket": {
+            "clean": {
+              "episodes": 10,
+              "successes": 4
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "place_bread_skillet": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "place_burger_fries": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 7
+            }
+          },
+          "place_can_basket": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "place_cans_plasticbox": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 8
+            }
+          },
+          "place_container_plate": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 9
+            }
+          },
+          "place_dual_shoes": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_empty_cup": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "place_fan": {
+            "clean": {
+              "episodes": 10,
+              "successes": 3
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 5
+            }
+          },
+          "place_mouse_pad": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "place_object_basket": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "place_object_scale": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "place_object_stand": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "place_phone_stand": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "place_shoe": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "press_stapler": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "put_bottles_dustbin": {
+            "clean": {
+              "episodes": 10,
+              "successes": 4
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "put_object_cabinet": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "rotate_qrcode": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "scan_object": {
+            "clean": {
+              "episodes": 10,
+              "successes": 4
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "shake_bottle": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 10
+            }
+          },
+          "shake_bottle_horizontally": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 10
+            }
+          },
+          "stack_blocks_three": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "stack_blocks_two": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "stack_bowls_three": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "stack_bowls_two": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 9
+            }
+          },
+          "stamp_seal": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "turn_switch": {
+            "clean": {
+              "episodes": 10,
+              "successes": 3
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          }
+        },
+        "completed_on": "2026-10-09",
+        "inference_runtime": [
+          {
+            "attention_implementation": "eager",
+            "autocast": false,
+            "compile": false,
+            "cuda_version": "12.8",
+            "gpu_memory_bytes": 42406903808,
+            "gpu_name": "NVIDIA A100-SXM4-40GB",
+            "max_clients": 6,
+            "model_replicas": 1,
+            "precision": "fp32",
+            "tf32": false,
+            "torch_version": "2.8.0+cu128",
+            "vision_attention_precision_note": "Official FA2 vision patch internally casts FP32 Q/K/V to BF16, then restores output dtype; FP32 here denotes official FP32 parameter/main-path mode, not all operations IEEE FP32."
+          },
+          {
+            "attention_implementation": "eager",
+            "autocast": false,
+            "compile": false,
+            "cuda_version": "12.8",
+            "gpu_memory_bytes": 42406903808,
+            "gpu_name": "NVIDIA A100-SXM4-40GB",
+            "max_clients": 6,
+            "model_replicas": 1,
+            "precision": "fp32",
+            "tf32": false,
+            "torch_version": "2.8.0+cu128",
+            "vision_attention_precision_note": "Official FA2 vision patch internally casts FP32 Q/K/V to BF16, then restores output dtype; FP32 here denotes official FP32 parameter/main-path mode, not all operations IEEE FP32."
+          },
+          {
+            "attention_implementation": "eager",
+            "autocast": false,
+            "compile": false,
+            "cuda_version": "12.8",
+            "gpu_memory_bytes": 42406903808,
+            "gpu_name": "NVIDIA A100-SXM4-40GB",
+            "max_clients": 6,
+            "model_replicas": 1,
+            "precision": "fp32",
+            "tf32": false,
+            "torch_version": "2.8.0+cu128",
+            "vision_attention_precision_note": "Official FA2 vision patch internally casts FP32 Q/K/V to BF16, then restores output dtype; FP32 here denotes official FP32 parameter/main-path mode, not all operations IEEE FP32."
+          }
+        ],
+        "instruction_protocol_note": "clean uses seen template/object vocabulary; randomized uses unseen instructions. This split changes both scene setting and instruction pool; not a pure visual randomization ablation.",
+        "instruction_types": {
+          "seen": {
+            "episodes": 500,
+            "successes": 381
+          },
+          "unseen": {
+            "episodes": 500,
+            "successes": 204
+          }
+        },
+        "metrics": {
+          "clean": {
+            "completed": 500,
+            "mean_episode_wall_seconds": 28.920957204053643,
+            "planned": 500,
+            "success_rate_among_completed": 0.762,
+            "successes": 381
+          },
+          "overall": {
+            "completed": 1000,
+            "mean_episode_wall_seconds": 34.47787418675865,
+            "planned": 1000,
+            "success_rate_among_completed": 0.585,
+            "successes": 585
+          },
+          "randomized": {
+            "completed": 500,
+            "mean_episode_wall_seconds": 40.03479116946366,
+            "planned": 500,
+            "success_rate_among_completed": 0.408,
+            "successes": 204
+          }
+        },
+        "render_gpu": "NVIDIA GeForce RTX 5090 32GB",
+        "subset_commit": "b5abe512dafd400736c6dca5905f2fd262dd9029",
+        "subset_id": "robotwin-eval-subset-v2-seen-unseen",
+        "workers": [
+          4,
+          6
+        ]
+      },
+      "repo_id": "ar-mine/lingbot-vla-v2-6b-e5-c3-epoch2-step17180",
+      "training": {
+        "automatic_restarts": 0,
+        "epochs": 2,
+        "frames": 549787,
+        "global_batch_size": 64,
+        "gpu_count": 4,
+        "gpu_model": "NVIDIA A100-SXM4-40GB",
+        "gpu_vram_mib": 40960,
+        "gpus_per_node": 4,
+        "gradient_accumulation_steps": 2,
+        "held_out_trajectories": 0,
+        "initialization": "official_base_fresh",
+        "last_training_loss": 0.019561767578125,
+        "micro_batch_size": 8,
+        "nodes": 1,
+        "optimizer_steps": 17180,
+        "requested_cpus_per_node": 64,
+        "requested_memory_gb_per_node": 440,
+        "source_archive_sha256": "830d1e28a0dbff4d8d7a127ac236fe8e6da88e3b1096e581914ad5288967e10c",
+        "training_cpu_model": "not captured in preserved allocation/binding record",
+        "training_seconds": 93651.12558245659,
+        "trajectories": 2500,
+        "validation_enabled": false
+      }
+    },
+    "ep6": {
+      "evaluation": {
+        "by_task": {
+          "adjust_bottle": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 9
+            }
+          },
+          "beat_block_hammer": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "blocks_ranking_rgb": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "blocks_ranking_size": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "click_alarmclock": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "click_bell": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 5
+            }
+          },
+          "dump_bin_bigbin": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 7
+            }
+          },
+          "grab_roller": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 5
+            }
+          },
+          "handover_block": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "handover_mic": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "hanging_mug": {
+            "clean": {
+              "episodes": 10,
+              "successes": 4
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "lift_pot": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "move_can_pot": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "move_pillbottle_pad": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "move_playingcard_away": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "move_stapler_pad": {
+            "clean": {
+              "episodes": 10,
+              "successes": 2
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "open_laptop": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "open_microwave": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "pick_diverse_bottles": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "pick_dual_bottles": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "place_a2b_left": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "place_a2b_right": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "place_bread_basket": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "place_bread_skillet": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "place_burger_fries": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 8
+            }
+          },
+          "place_can_basket": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_cans_plasticbox": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 7
+            }
+          },
+          "place_container_plate": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 8
+            }
+          },
+          "place_dual_shoes": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_empty_cup": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "place_fan": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_mouse_pad": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "place_object_basket": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "place_object_scale": {
+            "clean": {
+              "episodes": 10,
+              "successes": 7
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "place_object_stand": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "place_phone_stand": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "place_shoe": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 5
+            }
+          },
+          "press_stapler": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 4
+            }
+          },
+          "put_bottles_dustbin": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 3
+            }
+          },
+          "put_object_cabinet": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "rotate_qrcode": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          },
+          "scan_object": {
+            "clean": {
+              "episodes": 10,
+              "successes": 8
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 2
+            }
+          },
+          "shake_bottle": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 8
+            }
+          },
+          "shake_bottle_horizontally": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 10
+            }
+          },
+          "stack_blocks_three": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 5
+            }
+          },
+          "stack_blocks_two": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 5
+            }
+          },
+          "stack_bowls_three": {
+            "clean": {
+              "episodes": 10,
+              "successes": 9
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "stack_bowls_two": {
+            "clean": {
+              "episodes": 10,
+              "successes": 10
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 6
+            }
+          },
+          "stamp_seal": {
+            "clean": {
+              "episodes": 10,
+              "successes": 5
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 1
+            }
+          },
+          "turn_switch": {
+            "clean": {
+              "episodes": 10,
+              "successes": 3
+            },
+            "randomized": {
+              "episodes": 10,
+              "successes": 0
+            }
+          }
+        },
+        "completed_on": "2026-10-12",
+        "inference_runtime": [
+          {
+            "attention_implementation": "eager",
+            "autocast": false,
+            "compile": false,
+            "cuda_version": "12.8",
+            "gpu_memory_bytes": 42406903808,
+            "gpu_name": "NVIDIA A100-SXM4-40GB",
+            "max_clients": 6,
+            "model_replicas": 1,
+            "precision": "fp32",
+            "tf32": false,
+            "torch_version": "2.8.0+cu128",
+            "vision_attention_precision_note": "Official FA2 vision patch internally casts FP32 Q/K/V to BF16, then restores output dtype; FP32 here denotes official FP32 parameter/main-path mode, not all operations IEEE FP32."
+          }
+        ],
+        "instruction_protocol_note": "clean uses seen template/object vocabulary; randomized uses unseen instructions. This split changes both scene setting and instruction pool; not a pure visual randomization ablation.",
+        "instruction_types": {
+          "seen": {
+            "episodes": 500,
+            "successes": 416
+          },
+          "unseen": {
+            "episodes": 500,
+            "successes": 178
+          }
+        },
+        "metrics": {
+          "clean": {
+            "completed": 500,
+            "mean_episode_wall_seconds": 32.501751442580485,
+            "planned": 500,
+            "success_rate_among_completed": 0.832,
+            "successes": 416
+          },
+          "overall": {
+            "completed": 1000,
+            "mean_episode_wall_seconds": 41.383597164122506,
+            "planned": 1000,
+            "success_rate_among_completed": 0.594,
+            "successes": 594
+          },
+          "randomized": {
+            "completed": 500,
+            "mean_episode_wall_seconds": 50.26544288566453,
+            "planned": 500,
+            "success_rate_among_completed": 0.356,
+            "successes": 178
+          }
+        },
+        "render_gpu": "NVIDIA GeForce RTX 5090 32GB",
+        "subset_commit": "b5abe512dafd400736c6dca5905f2fd262dd9029",
+        "subset_id": "robotwin-eval-subset-v2-seen-unseen",
+        "workers": [
+          6
+        ]
+      },
+      "repo_id": "ar-mine/lingbot-vla-v2-6b-e5-c3-epoch6-step17178",
+      "training": {
+        "automatic_restarts": 0,
+        "epochs": 6,
+        "frames": 549787,
+        "global_batch_size": 192,
+        "gpu_count": 8,
+        "gpu_model": "NVIDIA A100-SXM4-40GB",
+        "gpu_vram_mib": 40960,
+        "gpus_per_node": 4,
+        "gradient_accumulation_steps": 2,
+        "held_out_trajectories": 0,
+        "initialization": "official_base_fresh",
+        "last_training_loss": 0.018779754638671875,
+        "micro_batch_size": 12,
+        "nodes": 2,
+        "optimizer_steps": 17178,
+        "requested_cpus_per_node": 64,
+        "requested_memory_gb_per_node": 440,
+        "source_archive_sha256": "77c95a4d09b5dc44358b46c3598203f09d1f1de26540e2883c15039212816c0a",
+        "training_cpu_model": "not captured in preserved allocation/binding record",
+        "training_seconds": 165183.77823376656,
+        "trajectories": 2500,
+        "validation_enabled": false
+      }
+    }
+  },
+  "pairing": {
+    "initial_observation_hash_mismatches": 0,
+    "scope": "All 1000 accepted initial RGB and public state hashes match between endpoints; policy failures accepted, infrastructure retries excluded.",
+    "shared_episode_ids": 1000
+  }
+}

SOURCE_MANIFEST.json

@@ -0,0 +1,1410 @@
+{
+  "files": {
+    "configs/augmentation/c3_v1.json": {
+      "export_sha256": "754827db7505595b161976eac53cba51f00a592f884bfb8434d7b5f4a7781904",
+      "original_sha256": "754827db7505595b161976eac53cba51f00a592f884bfb8434d7b5f4a7781904"
+    },
+    "configs/ep2_training.yaml": {
+      "export_sha256": "e268943fc0f87701a40f58fcd095e0452eae2d51f1b836c301e52ad0d318d92b",
+      "original_sha256": "8c3f404cc690bb491e1b1b50f6a8a162b2a4d2c1cc6a8093a1f31070c501bf37"
+    },
+    "configs/ep6_training.yaml": {
+      "export_sha256": "f39cd9bbadfaea705e0b6647e9a869cdc40140907dba8bd369db1edd8ee17701",
+      "original_sha256": "a6c804837d3cdb1d140e9acd49db8ae0ff9926eac46c399a63b0aa213e61799b"
+    },
+    "configs/phase4_robot_configs/robotwin.yaml": {
+      "export_sha256": "4c9d1b13a6d757fd4d6fa04a0646e264e6d3a9929b6adce2fbe3296945dcc4b6",
+      "original_sha256": "4c9d1b13a6d757fd4d6fa04a0646e264e6d3a9929b6adce2fbe3296945dcc4b6"
+    },
+    "deployment/finetune/e5_8gpu_rank_entry.py": {
+      "export_sha256": "4f41a23cb82b19649fc09bd149196b448f3d616cee5b2e37b93ef082f8485f6a",
+      "original_sha256": "4f41a23cb82b19649fc09bd149196b448f3d616cee5b2e37b93ef082f8485f6a"
+    },
+    "deployment/finetune/e5_rank_entry.py": {
+      "export_sha256": "40d9de5125b987978d60a4cdda8e14b17ac5eedf26bfb856b7da288368621d08",
+      "original_sha256": "40d9de5125b987978d60a4cdda8e14b17ac5eedf26bfb856b7da288368621d08"
+    },
+    "manifests/e5_allclean_train.txt": {
+      "export_sha256": "373d8406d26cc429b08bc1c120fd8e03586beb5391029024e3b05a687a88778d",
+      "original_sha256": "000344f11cf60771a0b39685f82442aea54b19563872429cc9acd6361e613491"
+    },
+    "manifests/norm_stats/robotwin_clean_train_s7.json": {
+      "export_sha256": "51f709ad7b1c9f5b0d94711b96ed4eb56a711791b5720f8291ac1cb727990205",
+      "original_sha256": "51f709ad7b1c9f5b0d94711b96ed4eb56a711791b5720f8291ac1cb727990205"
+    },
+    "scripts/e5_rollout_history.py": {
+      "export_sha256": "fd0b6aca5d856af136fd6445d2e3284e38be38aade26444e50144d237fc2dd8e",
+      "original_ep2_sha256": "fd0b6aca5d856af136fd6445d2e3284e38be38aade26444e50144d237fc2dd8e",
+      "original_ep6_sha256": "fd0b6aca5d856af136fd6445d2e3284e38be38aade26444e50144d237fc2dd8e"
+    },
+    "scripts/eval_common.py": {
+      "export_sha256": "f35f0dbc45e0d2fc171b4658d3dd829275298942266e8bad6a45d43e7d344780",
+      "original_ep2_sha256": "f35f0dbc45e0d2fc171b4658d3dd829275298942266e8bad6a45d43e7d344780",
+      "original_ep6_sha256": "f35f0dbc45e0d2fc171b4658d3dd829275298942266e8bad6a45d43e7d344780"
+    },
+    "scripts/eval_device.py": {
+      "export_sha256": "dc356debea6ef97a19b0e5eb6af24c78f50c8f9e1e7fa0744e682c1b8e07edf8",
+      "original_ep2_sha256": "dc356debea6ef97a19b0e5eb6af24c78f50c8f9e1e7fa0744e682c1b8e07edf8",
+      "original_ep6_sha256": "dc356debea6ef97a19b0e5eb6af24c78f50c8f9e1e7fa0744e682c1b8e07edf8"
+    },
+    "scripts/eval_diagnostics.py": {
+      "export_sha256": "67076271605ee6bdf454dd51eb6f3944b7fa545dd63eb35874f55b9f526dccfc",
+      "original_ep2_sha256": "67076271605ee6bdf454dd51eb6f3944b7fa545dd63eb35874f55b9f526dccfc",
+      "original_ep6_sha256": "67076271605ee6bdf454dd51eb6f3944b7fa545dd63eb35874f55b9f526dccfc"
+    },
+    "scripts/eval_model_registry.py": {
+      "export_sha256": "b18f4d3496e3e8c82e673124be98ec44fdd21cf330ec8d051a6b6ae3206947f7",
+      "original_ep2_sha256": "d0c9e13312627b45f5e4ced4d25acecfb46d2214c90edd1c8654accc51488b42",
+      "original_ep6_sha256": "aace6c808f32d1279ad06e6ff187e54f001c812df2cf4deb5947f8e87848821c"
+    },
+    "scripts/eval_official_worker.py": {
+      "export_sha256": "ba5f676fc221ed839ac67c8c6feb188dc6bb4ba311374ee1dc57308480d980a6",
+      "original_ep2_sha256": "ba5f676fc221ed839ac67c8c6feb188dc6bb4ba311374ee1dc57308480d980a6",
+      "original_ep6_sha256": "ba5f676fc221ed839ac67c8c6feb188dc6bb4ba311374ee1dc57308480d980a6"
+    },
+    "scripts/eval_planner_optimization.py": {
+      "export_sha256": "e7311bd1ed2bc9b30eb14643e6f46b9ed45d71439c789cd484eedd3e00a53f10",
+      "original_ep2_sha256": "e7311bd1ed2bc9b30eb14643e6f46b9ed45d71439c789cd484eedd3e00a53f10",
+      "original_ep6_sha256": "e7311bd1ed2bc9b30eb14643e6f46b9ed45d71439c789cd484eedd3e00a53f10"
+    },
+    "scripts/frozen_eval_subset.py": {
+      "export_sha256": "ebc42c0388f8daf4f7a7cc709b97d8a9ddd4c125651d301a408db100828f1b37",
+      "original_ep2_sha256": "ebc42c0388f8daf4f7a7cc709b97d8a9ddd4c125651d301a408db100828f1b37",
+      "original_ep6_sha256": "ebc42c0388f8daf4f7a7cc709b97d8a9ddd4c125651d301a408db100828f1b37"
+    },
+    "scripts/hybrid_capacity_telemetry.py": {
+      "export_sha256": "e018c8e580a773437793219aecc74974848adc4468f138735c4fabf5487b1c19",
+      "original_ep2_sha256": "e018c8e580a773437793219aecc74974848adc4468f138735c4fabf5487b1c19",
+      "original_ep6_sha256": "e018c8e580a773437793219aecc74974848adc4468f138735c4fabf5487b1c19"
+    },
+    "scripts/hybrid_concurrent_server.py": {
+      "export_sha256": "1e4f18ccf699473c2d634dc34e876805bc8dd5f19ce1d4bac370a5405668704d",
+      "original_ep2_sha256": "1e4f18ccf699473c2d634dc34e876805bc8dd5f19ce1d4bac370a5405668704d",
+      "original_ep6_sha256": "1e4f18ccf699473c2d634dc34e876805bc8dd5f19ce1d4bac370a5405668704d"
+    },
+    "scripts/hybrid_transport.py": {
+      "export_sha256": "992683fb8e927959d40deafbad7dbe6a15c19d1f13bccc409b2b47669ca3a13a",
+      "original_ep2_sha256": "992683fb8e927959d40deafbad7dbe6a15c19d1f13bccc409b2b47669ca3a13a",
+      "original_ep6_sha256": "992683fb8e927959d40deafbad7dbe6a15c19d1f13bccc409b2b47669ca3a13a"
+    },
+    "scripts/hybrid_worker.py": {
+      "export_sha256": "ca20e8fff75652e9438d66fbddec2ceec27ae2c762268902af87a8cac88734da",
+      "original_ep2_sha256": "ca20e8fff75652e9438d66fbddec2ceec27ae2c762268902af87a8cac88734da",
+      "original_ep6_sha256": "ca20e8fff75652e9438d66fbddec2ceec27ae2c762268902af87a8cac88734da"
+    },
+    "scripts/release_eval.py": {
+      "export_sha256": "399bd3684c3c8fed493640484346a2f74efb71f0236130b66d39f61a035cebca",
+      "origin": "new_release_wrapper"
+    },
+    "scripts/serve_eval_policy.py": {
+      "export_sha256": "e490b53916c159b744e578cd83761a63faf53d33e63ac74aca46c261264e6c72",
+      "original_ep2_sha256": "e490b53916c159b744e578cd83761a63faf53d33e63ac74aca46c261264e6c72",
+      "original_ep6_sha256": "e490b53916c159b744e578cd83761a63faf53d33e63ac74aca46c261264e6c72"
+    },
+    "scripts/serve_hybrid_concurrent_policy.py": {
+      "export_sha256": "65fc3c90d778425dd7e4b04417af38e1b4d87c64117d8e3d1788ebe813c1f7d5",
+      "original_ep2_sha256": "65fc3c90d778425dd7e4b04417af38e1b4d87c64117d8e3d1788ebe813c1f7d5",
+      "original_ep6_sha256": "65fc3c90d778425dd7e4b04417af38e1b4d87c64117d8e3d1788ebe813c1f7d5"
+    },
+    "src/lora_eval_loading.py": {
+      "export_sha256": "0de7d45c11687311e1a165bbcf149a84234d1e989043760499ba11bb7eeca1ab",
+      "original_ep2_sha256": "0de7d45c11687311e1a165bbcf149a84234d1e989043760499ba11bb7eeca1ab",
+      "original_ep6_sha256": "0de7d45c11687311e1a165bbcf149a84234d1e989043760499ba11bb7eeca1ab"
+    },
+    "src/lora_eval_policy.py": {
+      "export_sha256": "da5e682843e77ce2b73995a7fbce544d678c6ad016325bf31cc8a2e6bb1ce8dc",
+      "original_ep2_sha256": "da5e682843e77ce2b73995a7fbce544d678c6ad016325bf31cc8a2e6bb1ce8dc",
+      "original_ep6_sha256": "da5e682843e77ce2b73995a7fbce544d678c6ad016325bf31cc8a2e6bb1ce8dc"
+    },
+    "src/phase4_policy.py": {
+      "export_sha256": "b19d4d754a54cac1fc53346e8ac639d3377a8ec48e37d5b2aa7af15233ce0259",
+      "original_ep2_sha256": "b19d4d754a54cac1fc53346e8ac639d3377a8ec48e37d5b2aa7af15233ce0259",
+      "original_ep6_sha256": "b19d4d754a54cac1fc53346e8ac639d3377a8ec48e37d5b2aa7af15233ce0259"
+    },
+    "third_party/lingbot-vla-v2/LICENSE": {
+      "export_sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+      "original_sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    },
+    "third_party/lingbot-vla-v2/configs/robot_configs/agilex_cobot_magic.yaml": {
+      "export_sha256": "8ab06b150fe28d7f0f90e67df445325d6b31d4a11929b46b7e06159d94922baa",
+      "original_sha256": "8ab06b150fe28d7f0f90e67df445325d6b31d4a11929b46b7e06159d94922baa"
+    },
+    "third_party/lingbot-vla-v2/configs/robot_configs/robotwin.yaml": {
+      "export_sha256": "2c2a26509fc9662a8ada64adaa7fa959627dd6dadc6b48b680c4285da2d8ffd8",
+      "original_sha256": "2c2a26509fc9662a8ada64adaa7fa959627dd6dadc6b48b680c4285da2d8ffd8"
+    },
+    "third_party/lingbot-vla-v2/configs/vla/norm_compute/post_data.yaml": {
+      "export_sha256": "8d1537aedf05f030c00cf8c1ddad9919d9e609148cdbb3927925682f6c109c41",
+      "original_sha256": "8d1537aedf05f030c00cf8c1ddad9919d9e609148cdbb3927925682f6c109c41"
+    },
+    "third_party/lingbot-vla-v2/configs/vla/real_robot/real_robot.yaml": {
+      "export_sha256": "8d5ddcd1d6caa846c4c0442cc3e9ea3f25078c6f274536d1ee1caadb560d8124",
+      "original_sha256": "8d5ddcd1d6caa846c4c0442cc3e9ea3f25078c6f274536d1ee1caadb560d8124"
+    },
+    "third_party/lingbot-vla-v2/configs/vla/robotwin/robotwin.yaml": {
+      "export_sha256": "ee915e4ad34589a6def35c9e3c12bb8ff7d9f768dfc7ad44ce789fa7aaea57e2",
+      "original_sha256": "ee915e4ad34589a6def35c9e3c12bb8ff7d9f768dfc7ad44ce789fa7aaea57e2"
+    },
+    "third_party/lingbot-vla-v2/deploy/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/deploy/executed_action_history.py": {
+      "export_sha256": "8b657fe5da0b29e1930c51aac234802021ce3eb2afd248461dba6b075044f294",
+      "original_sha256": "8b657fe5da0b29e1930c51aac234802021ce3eb2afd248461dba6b075044f294"
+    },
+    "third_party/lingbot-vla-v2/deploy/image_tools.py": {
+      "export_sha256": "d48b4bd7f44e79fe6db8a8e07c9161144fa250be686e1245014a8b47e6171977",
+      "original_sha256": "d48b4bd7f44e79fe6db8a8e07c9161144fa250be686e1245014a8b47e6171977"
+    },
+    "third_party/lingbot-vla-v2/deploy/lingbot_vla_v2_policy.py": {
+      "export_sha256": "008e0e3aab20a5a2c70131a868226308d59320020f11c1bd19a3c51b62641a9e",
+      "original_sha256": "13599b07e83086e7cffe69a64eda00f2377e0c2ade2fd9b3675fb0a3e11ade10"
+    },
+    "third_party/lingbot-vla-v2/deploy/msgpack_numpy.py": {
+      "export_sha256": "c04568948fcee52b691e3be4b6cffb759f7e79ad67530fcd5d23095a0d13c057",
+      "original_sha256": "c04568948fcee52b691e3be4b6cffb759f7e79ad67530fcd5d23095a0d13c057"
+    },
+    "third_party/lingbot-vla-v2/deploy/utils.py": {
+      "export_sha256": "b90a4d367dcef61cfb86d85e9103af067ab8b8df99c71b597495e573b5bc991e",
+      "original_sha256": "b90a4d367dcef61cfb86d85e9103af067ab8b8df99c71b597495e573b5bc991e"
+    },
+    "third_party/lingbot-vla-v2/deploy/websocket_client_policy.py": {
+      "export_sha256": "4642c7ab25494b3113372b5abdeaffab9c15b8d31a33c8b7c89df658fdca4151",
+      "original_sha256": "4642c7ab25494b3113372b5abdeaffab9c15b8d31a33c8b7c89df658fdca4151"
+    },
+    "third_party/lingbot-vla-v2/deploy/websocket_policy_server.py": {
+      "export_sha256": "67bebd23c6d82803f89978a79de7829bd32a62f4c32e485e6e0540204ede565b",
+      "original_sha256": "67bebd23c6d82803f89978a79de7829bd32a62f4c32e485e6e0540204ede565b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/__init__.py": {
+      "export_sha256": "fcfeb5547f909133485a146441ddcc3072447063914eace4793e487967a88f78",
+      "original_sha256": "fcfeb5547f909133485a146441ddcc3072447063914eace4793e487967a88f78"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/checkpoint/__init__.py": {
+      "export_sha256": "5b68a96dcd313876a211b3023e3e9dbbbedff96b6d5bddfd155c910525d89f96",
+      "original_sha256": "5b68a96dcd313876a211b3023e3e9dbbbedff96b6d5bddfd155c910525d89f96"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/checkpoint/checkpointer.py": {
+      "export_sha256": "152532e120534e95342ec7398e1aae691714093ad0363b95e17363f908a68871",
+      "original_sha256": "152532e120534e95342ec7398e1aae691714093ad0363b95e17363f908a68871"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/checkpoint/format_utils.py": {
+      "export_sha256": "25dc1eead76e7cbf1d773196927f472d452efebc4eef53a586ea5d257941e2b5",
+      "original_sha256": "25dc1eead76e7cbf1d773196927f472d452efebc4eef53a586ea5d257941e2b5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/__init__.py": {
+      "export_sha256": "db4230123017f1d3f684b402e46b8d94bdd6583f9bc18100c7401855a2b4af2b",
+      "original_sha256": "db4230123017f1d3f684b402e46b8d94bdd6583f9bc18100c7401855a2b4af2b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/batching_strategy.py": {
+      "export_sha256": "3fae066e32fc83d4df3a15a333bd30d1e4800886c750ade9bd0921a5e569960b",
+      "original_sha256": "3fae066e32fc83d4df3a15a333bd30d1e4800886c750ade9bd0921a5e569960b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/chat_template.py": {
+      "export_sha256": "54fa29e91838dbab619dc33e9c8619948c0778ac7b1037b7674acfd7930c2126",
+      "original_sha256": "54fa29e91838dbab619dc33e9c8619948c0778ac7b1037b7674acfd7930c2126"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/constants.py": {
+      "export_sha256": "126d4dae9fe60353d4ff3f8a94cb2be0bd1a2ea769771106ce6f73a48c7dd77e",
+      "original_sha256": "126d4dae9fe60353d4ff3f8a94cb2be0bd1a2ea769771106ce6f73a48c7dd77e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/data_collator.py": {
+      "export_sha256": "02505732b0143c39271b38b215d7d72a197f9f95fa9cf9d5e6f18ded51b2cefa",
+      "original_sha256": "02505732b0143c39271b38b215d7d72a197f9f95fa9cf9d5e6f18ded51b2cefa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/data_loader.py": {
+      "export_sha256": "3e50b30313a5178295ccc524cbb17cda40fbb0d7c18b85736d2ab1599fabe819",
+      "original_sha256": "3e50b30313a5178295ccc524cbb17cda40fbb0d7c18b85736d2ab1599fabe819"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/data_transform.py": {
+      "export_sha256": "6dd6ab7d3a02a243b548b297045500e8310cdfb7f3fffa493be4027232fabb56",
+      "original_sha256": "6dd6ab7d3a02a243b548b297045500e8310cdfb7f3fffa493be4027232fabb56"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/dataset.py": {
+      "export_sha256": "120991b363c4c4457546de56913d9fb6d5fbcf433a790dba0bc28ff96df15809",
+      "original_sha256": "120991b363c4c4457546de56913d9fb6d5fbcf433a790dba0bc28ff96df15809"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/dynamic_batching.py": {
+      "export_sha256": "e5fadeaf804fc78054ca836b3fb21c7f73e1fb9e934519bd06bb88bcbee06416",
+      "original_sha256": "e5fadeaf804fc78054ca836b3fb21c7f73e1fb9e934519bd06bb88bcbee06416"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/multimodal/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/multimodal/data_collator.py": {
+      "export_sha256": "b59b5171481d8b16540279d700d4afc7a1270d40e8e8de959930001753158cef",
+      "original_sha256": "b59b5171481d8b16540279d700d4afc7a1270d40e8e8de959930001753158cef"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/multimodal/multimodal_chat_template.py": {
+      "export_sha256": "4088ff01a8748e7c21024b2966068d98724fd30930f29eb0287be0925561e9d4",
+      "original_sha256": "4088ff01a8748e7c21024b2966068d98724fd30930f29eb0287be0925561e9d4"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/multimodal/multimodal_transform.py": {
+      "export_sha256": "1dbd3e1fba5a50249b440a3f5aa4f32595726d94419a16ad95b758407a2b1de3",
+      "original_sha256": "1dbd3e1fba5a50249b440a3f5aa4f32595726d94419a16ad95b758407a2b1de3"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/multimodal/preprocess.py": {
+      "export_sha256": "d867f93a9d3b6fde2209bdf85dacea2a3d6ea3bf782b2c1bc096ac1dbbb4c950",
+      "original_sha256": "d867f93a9d3b6fde2209bdf85dacea2a3d6ea3bf782b2c1bc096ac1dbbb4c950"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/__init__.py": {
+      "export_sha256": "362282de0f8ac1ab332571a3e52ad29e40430a9cd43c7f1f7de003a0d77abb67",
+      "original_sha256": "362282de0f8ac1ab332571a3e52ad29e40430a9cd43c7f1f7de003a0d77abb67"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/base_dataset.py": {
+      "export_sha256": "8f05c17b13752233085a38d05cae7f456b0bf47d758d14beb099af0b611c922c",
+      "original_sha256": "8f05c17b13752233085a38d05cae7f456b0bf47d758d14beb099af0b611c922c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/c3_augmentation.py": {
+      "export_sha256": "82e917b8170a93f64913672ac5081fc2f4a2710801359babfa0f9fffbef3dd92",
+      "original_sha256": "82e917b8170a93f64913672ac5081fc2f4a2710801359babfa0f9fffbef3dd92"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/ee_pose_transform.py": {
+      "export_sha256": "07a54ad75ca3bb0a7f65ab8e726452548679ae272d960c20b742c5222f13ea53",
+      "original_sha256": "07a54ad75ca3bb0a7f65ab8e726452548679ae272d960c20b742c5222f13ea53"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/multi_vla_dataset.py": {
+      "export_sha256": "c484c0c10236b35eb133fdc3cb9488fe7c0df0bde4830cdf545b96d3f7de5085",
+      "original_sha256": "c484c0c10236b35eb133fdc3cb9488fe7c0df0bde4830cdf545b96d3f7de5085"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/transform.py": {
+      "export_sha256": "e8f237c99ebf6cb4b16178b9bca7fba147337071f004aca8a135ac11f8ca2e49",
+      "original_sha256": "e8f237c99ebf6cb4b16178b9bca7fba147337071f004aca8a135ac11f8ca2e49"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/utils.py": {
+      "export_sha256": "d047281b00bb8fb4cfa594ed0704840a8125fab28f9da91b97d45bb1eed2c7c9",
+      "original_sha256": "d047281b00bb8fb4cfa594ed0704840a8125fab28f9da91b97d45bb1eed2c7c9"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/data/vla_data/video_utils.py": {
+      "export_sha256": "016244862ef3bae740ecd55314028dc64c09893553bea2d639dd7b0273110746",
+      "original_sha256": "016244862ef3bae740ecd55314028dc64c09893553bea2d639dd7b0273110746"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/checkpoint.py": {
+      "export_sha256": "e6c98c3ed48849d79d1f981ab65b8f19011120391ef8f4734e13bf8b12630f8d",
+      "original_sha256": "e6c98c3ed48849d79d1f981ab65b8f19011120391ef8f4734e13bf8b12630f8d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/fsdp/__init__.py": {
+      "export_sha256": "ea33030a80e0bf61602e39e8e08fbe612197ba71a9c805eadb7f98afd6409287",
+      "original_sha256": "ea33030a80e0bf61602e39e8e08fbe612197ba71a9c805eadb7f98afd6409287"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/fsdp/clip_grad_norm.py": {
+      "export_sha256": "bea38ed7ca18f5cd68f1b68407dbe6e5d0ec30ca0086a7c8712ae16decb8775a",
+      "original_sha256": "bea38ed7ca18f5cd68f1b68407dbe6e5d0ec30ca0086a7c8712ae16decb8775a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/fsdp/extension.py": {
+      "export_sha256": "3fa259f460f91b49ffb0974af08b26cee2a2b4b9626e7dc20f73de704f9ea8f1",
+      "original_sha256": "3fa259f460f91b49ffb0974af08b26cee2a2b4b9626e7dc20f73de704f9ea8f1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/fsdp/initialize.py": {
+      "export_sha256": "54ed6958c2be1cb1a0d43d6e33cfe9aa2037273bd8239ecc11410581b1c362bb",
+      "original_sha256": "54ed6958c2be1cb1a0d43d6e33cfe9aa2037273bd8239ecc11410581b1c362bb"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/fsdp2/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/fsdp2/clip_grad_norm.py": {
+      "export_sha256": "0743ff0c1f175cafcd2d57cbf78031b8ed97472acf5e98d3fea1dae375a9874f",
+      "original_sha256": "0743ff0c1f175cafcd2d57cbf78031b8ed97472acf5e98d3fea1dae375a9874f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/moe/__init__.py": {
+      "export_sha256": "1dcf10d80db3716f81de18b07bbccb9d7d4f31d4204e60e8deceacc1f587c31a",
+      "original_sha256": "1dcf10d80db3716f81de18b07bbccb9d7d4f31d4204e60e8deceacc1f587c31a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/moe/comm.py": {
+      "export_sha256": "6c4a676ae00ae8bbbb4fd9e939b32cd8a08dd0f34bead8171656731dd5ff1b99",
+      "original_sha256": "6c4a676ae00ae8bbbb4fd9e939b32cd8a08dd0f34bead8171656731dd5ff1b99"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/moe/moe_layer.py": {
+      "export_sha256": "9941aae19371b8b06ba34f0857403a901b78882f7f78fb50f01654a159d49764",
+      "original_sha256": "9941aae19371b8b06ba34f0857403a901b78882f7f78fb50f01654a159d49764"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/moe/moe_utils.py": {
+      "export_sha256": "ae70dfd57a1ca723a606ed1d934743f71f6847b30b00595e536151bbf921a49d",
+      "original_sha256": "ae70dfd57a1ca723a606ed1d934743f71f6847b30b00595e536151bbf921a49d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/offloading.py": {
+      "export_sha256": "044511219c31a33df46f381a40d5bca9dd5aea8ff6ee4cce6aaf5bea5c2688aa",
+      "original_sha256": "044511219c31a33df46f381a40d5bca9dd5aea8ff6ee4cce6aaf5bea5c2688aa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/parallel_plan.py": {
+      "export_sha256": "48e8da68e4cc70ac5e955fbf10340fe7b0a5c2442120c8344f85cb6e66554837",
+      "original_sha256": "48e8da68e4cc70ac5e955fbf10340fe7b0a5c2442120c8344f85cb6e66554837"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/parallel_state.py": {
+      "export_sha256": "c15d7d0d509845a331ea5bc0503d7ebfac380a16b48d11ce4377ea6310b3dd7c",
+      "original_sha256": "c15d7d0d509845a331ea5bc0503d7ebfac380a16b48d11ce4377ea6310b3dd7c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/__init__.py": {
+      "export_sha256": "cba224d2e25125a28fabdd9dc43970460f8f1b288475672575379cdfe03ceaa7",
+      "original_sha256": "cba224d2e25125a28fabdd9dc43970460f8f1b288475672575379cdfe03ceaa7"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/async_ulysses.py": {
+      "export_sha256": "052b86c46f281376b339811e9ea42f394a417d435a6b11a8b573d59a545aa3ac",
+      "original_sha256": "052b86c46f281376b339811e9ea42f394a417d435a6b11a8b573d59a545aa3ac"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/async_ulysses_dit.py": {
+      "export_sha256": "9a28b37253108aaf4d38e34cccb516a47d3f7f7065a8c7bb70f191e68e08bdef",
+      "original_sha256": "9a28b37253108aaf4d38e34cccb516a47d3f7f7065a8c7bb70f191e68e08bdef"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/comm.py": {
+      "export_sha256": "aaee38fb444c6c4c9ae0e3f1e09e01da10808e299299e2d8be30fcf393ef1fd4",
+      "original_sha256": "aaee38fb444c6c4c9ae0e3f1e09e01da10808e299299e2d8be30fcf393ef1fd4"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/data.py": {
+      "export_sha256": "ab1081840a5704894c8f622a4558b424acb6189bd180aa8ecfbe2a301ee14b35",
+      "original_sha256": "ab1081840a5704894c8f622a4558b424acb6189bd180aa8ecfbe2a301ee14b35"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/loss.py": {
+      "export_sha256": "4d5ab17b522bced7b693870dbf0953055cb33f441abdd7ef3e757a45530bdf2d",
+      "original_sha256": "4d5ab17b522bced7b693870dbf0953055cb33f441abdd7ef3e757a45530bdf2d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/ulysses.py": {
+      "export_sha256": "25836baadf5c08a567c65774c45e4eed082860dc74dda1740a0f8880b5dd1d11",
+      "original_sha256": "25836baadf5c08a567c65774c45e4eed082860dc74dda1740a0f8880b5dd1d11"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/sequence_parallel/utils.py": {
+      "export_sha256": "5aa78940f3aa85aaea181528ac551d97a754034a7979b8ac4299965dc45a18dc",
+      "original_sha256": "5aa78940f3aa85aaea181528ac551d97a754034a7979b8ac4299965dc45a18dc"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/torch_parallelize.py": {
+      "export_sha256": "00d6e229fc5587f6590cfab07e581f39ffe272715999946ee50ae35c14bb6e5f",
+      "original_sha256": "00d6e229fc5587f6590cfab07e581f39ffe272715999946ee50ae35c14bb6e5f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/utils.py": {
+      "export_sha256": "90638562bd7a2eb63595cc18bba1fc5dc93cb3520820a9ecbad3e30f53e615b3",
+      "original_sha256": "90638562bd7a2eb63595cc18bba1fc5dc93cb3520820a9ecbad3e30f53e615b3"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/vescale_parallelize.py": {
+      "export_sha256": "a610275eceb40a0f1bcdc326b1eb3171aa9086b7a66b0b0c2ff0ee46ffba155c",
+      "original_sha256": "a610275eceb40a0f1bcdc326b1eb3171aa9086b7a66b0b0c2ff0ee46ffba155c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/distributed/vescale_plan.py": {
+      "export_sha256": "a5c157cf81a5c200ac4bb7dd8e20674730f541973e66cc86bc0276eebb3ba067",
+      "original_sha256": "a5c157cf81a5c200ac4bb7dd8e20674730f541973e66cc86bc0276eebb3ba067"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/__init__.py": {
+      "export_sha256": "e0d0fb7e7ac2f3e5fddbbea68dd4e06a2038dc723ce34a144d98307e61f2ad7e",
+      "original_sha256": "e0d0fb7e7ac2f3e5fddbbea68dd4e06a2038dc723ce34a144d98307e61f2ad7e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/auto.py": {
+      "export_sha256": "c7c01d27297eefdca3503fef0b2666662550c933c523a87e07597b5d8d2005f1",
+      "original_sha256": "c7c01d27297eefdca3503fef0b2666662550c933c523a87e07597b5d8d2005f1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/config_registry.py": {
+      "export_sha256": "3c5e1758e5c3acb0a9e28e1087b19424340cef614af7d99dd33ffd02b35c45ee",
+      "original_sha256": "3c5e1758e5c3acb0a9e28e1087b19424340cef614af7d99dd33ffd02b35c45ee"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/loader.py": {
+      "export_sha256": "dbac5bb3d6a901bd2ff4ef6c362022cc0096eb3561521a8b9eeaa5ddd18c683e",
+      "original_sha256": "dbac5bb3d6a901bd2ff4ef6c362022cc0096eb3561521a8b9eeaa5ddd18c683e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/modeling_layers.py": {
+      "export_sha256": "9f86f23ced2d9111a5a6a8b6a388fe56554b18650f8dd5168c690e6a846b149b",
+      "original_sha256": "9f86f23ced2d9111a5a6a8b6a388fe56554b18650f8dd5168c690e6a846b149b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/module_utils.py": {
+      "export_sha256": "1a982c7b7ff7391197d4bdd564493424fe31f6acbb4e79acd7c35629af545789",
+      "original_sha256": "1a982c7b7ff7391197d4bdd564493424fe31f6acbb4e79acd7c35629af545789"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/registry.py": {
+      "export_sha256": "25b2f06ac447fbbda79b04dbcda4260967d9a839ada35b6c721df2ef13a02f38",
+      "original_sha256": "25b2f06ac447fbbda79b04dbcda4260967d9a839ada35b6c721df2ef13a02f38"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/__init__.py": {
+      "export_sha256": "8beb7f9e986cf86c79caabd9bf916a72287c7e7f18a2d9aa762740fd89cdb4b4",
+      "original_sha256": "8beb7f9e986cf86c79caabd9bf916a72287c7e7f18a2d9aa762740fd89cdb4b4"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/__init__.py": {
+      "export_sha256": "24a6e4f8507703f4f3ae21f2206bc5ec6a713a6b76d171a43900a0cf932e38d7",
+      "original_sha256": "24a6e4f8507703f4f3ae21f2206bc5ec6a713a6b76d171a43900a0cf932e38d7"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/action_history.py": {
+      "export_sha256": "b75ebf1f9ad92e45dd913b082857563c6dbb887109b3d66f96e7a14315172b7c",
+      "original_sha256": "b75ebf1f9ad92e45dd913b082857563c6dbb887109b3d66f96e7a14315172b7c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/configuration_lingbot_vla.py": {
+      "export_sha256": "3b94da5f5aa66abbbf594491582417679a93a07b5826e2da1e1e958964d87707",
+      "original_sha256": "3b94da5f5aa66abbbf594491582417679a93a07b5826e2da1e1e958964d87707"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/flex_attention.py": {
+      "export_sha256": "c7ea18fc1b122e14b24775b4e0e983dbffc7dd0b02e91b03a5a1c4369eff3da9",
+      "original_sha256": "c7ea18fc1b122e14b24775b4e0e983dbffc7dd0b02e91b03a5a1c4369eff3da9"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/modeling_lingbot_vla.py": {
+      "export_sha256": "af6a365f05e4ccd7d2585368412be5d186a3afdabfc6e9eaf0c97e71a51037dc",
+      "original_sha256": "af6a365f05e4ccd7d2585368412be5d186a3afdabfc6e9eaf0c97e71a51037dc"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/modeling_lingbot_vla_v2.py": {
+      "export_sha256": "b17250f71e3c2af420e20308cd356440c23a448092221f8c32ff13ee034324a2",
+      "original_sha256": "b17250f71e3c2af420e20308cd356440c23a448092221f8c32ff13ee034324a2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/moe_load_balance.py": {
+      "export_sha256": "15dd33d388d503fc96b891e8ff2cb29415cefa5bb165f1450f847a7f0bbca833",
+      "original_sha256": "15dd33d388d503fc96b891e8ff2cb29415cefa5bb165f1450f847a7f0bbca833"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/qwen2_action_expert.py": {
+      "export_sha256": "2221459c676c27eb70e13edd29d6e25c2c6008a1fc3f0b7c820b8abbbf11aff6",
+      "original_sha256": "2221459c676c27eb70e13edd29d6e25c2c6008a1fc3f0b7c820b8abbbf11aff6"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/qwen3vl_in_vla.py": {
+      "export_sha256": "eb2202bd01916c891b366c90f9bf11a2782f9387031cc24ed08851b3d8f01e96",
+      "original_sha256": "eb2202bd01916c891b366c90f9bf11a2782f9387031cc24ed08851b3d8f01e96"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/qwenvl_in_vla.py": {
+      "export_sha256": "6320cbc1c71cfd51b98258e92782d601d00f0b33035bf50979a299fbe29ba7c3",
+      "original_sha256": "6320cbc1c71cfd51b98258e92782d601d00f0b33035bf50979a299fbe29ba7c3"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/state_history.py": {
+      "export_sha256": "5fedc852b0c10b14b9511e72ea8a4ccaff8cac234ab676414cfc30d4433124bf",
+      "original_sha256": "5fedc852b0c10b14b9511e72ea8a4ccaff8cac234ab676414cfc30d4433124bf"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/utils.py": {
+      "export_sha256": "aa8d55137c17a1efa78d3a8124a131ddacf8166b56a2d8802f68bc04b434e747",
+      "original_sha256": "aa8d55137c17a1efa78d3a8124a131ddacf8166b56a2d8802f68bc04b434e747"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/lingbot_vla/visual_history.py": {
+      "export_sha256": "29d2fa61e66aa37a5a7245588b57665de9d88bf869bb2889b6210865adbda391",
+      "original_sha256": "29d2fa61e66aa37a5a7245588b57665de9d88bf869bb2889b6210865adbda391"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/pi0/__init__.py": {
+      "export_sha256": "24a6e4f8507703f4f3ae21f2206bc5ec6a713a6b76d171a43900a0cf932e38d7",
+      "original_sha256": "24a6e4f8507703f4f3ae21f2206bc5ec6a713a6b76d171a43900a0cf932e38d7"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/pi0/flex_attention.py": {
+      "export_sha256": "f46e0fd09eddf4ccbeac21fbdea58685fb7e821e6850d3c190db11272ffc8d96",
+      "original_sha256": "f46e0fd09eddf4ccbeac21fbdea58685fb7e821e6850d3c190db11272ffc8d96"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/pi0/modeling_pi0.py": {
+      "export_sha256": "cb0186a313f124fc0d70c1957e2fbb6981dbe323bde1f305bc099ae68f1bf59d",
+      "original_sha256": "cb0186a313f124fc0d70c1957e2fbb6981dbe323bde1f305bc099ae68f1bf59d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/pi0/utils.py": {
+      "export_sha256": "7d5d67dbdeeec9d8038ae1445a952d23749938d2ad3d5da7e4f134183fa79bd1",
+      "original_sha256": "7d5d67dbdeeec9d8038ae1445a952d23749938d2ad3d5da7e4f134183fa79bd1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/LICENSE": {
+      "export_sha256": "ad7d951c80c5fc2b2bce035f2041bc0a0dbf9028c8ecc4c9a8e1fba8130b6b59",
+      "original_sha256": "ad7d951c80c5fc2b2bce035f2041bc0a0dbf9028c8ecc4c9a8e1fba8130b6b59"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/baselines/da_v2.py": {
+      "export_sha256": "897958984c030b2388c9801aa25053cd1bf1dd3be98bb4c131e8826d38685ae2",
+      "original_sha256": "897958984c030b2388c9801aa25053cd1bf1dd3be98bb4c131e8826d38685ae2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/baselines/da_v2_metric.py": {
+      "export_sha256": "d339b3e229b57601a28491cde80a93968826989a76251cbe4f7eff1ee87a49ee",
+      "original_sha256": "d339b3e229b57601a28491cde80a93968826989a76251cbe4f7eff1ee87a49ee"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/baselines/metric3d_v2.py": {
+      "export_sha256": "7f40a3f200f84947b30003d70f539da6f5e8242413b06d0edeef69977eb97d33",
+      "original_sha256": "7f40a3f200f84947b30003d70f539da6f5e8242413b06d0edeef69977eb97d33"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/baselines/moge.py": {
+      "export_sha256": "c245f279dcfb1abe68b18199c34fe065cbf94c6415b39b6a6601d078ab9a465e",
+      "original_sha256": "c245f279dcfb1abe68b18199c34fe065cbf94c6415b39b6a6601d078ab9a465e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/all_benchmarks.json": {
+      "export_sha256": "028d405eddf0e5c65cb7ad4f832d11fc9a73992c1acb260b2f1c64437cfa8b54",
+      "original_sha256": "028d405eddf0e5c65cb7ad4f832d11fc9a73992c1acb260b2f1c64437cfa8b54"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/ddad.json": {
+      "export_sha256": "bd5479209fa7541cbc189c30ba3a91d47ee3dda7d57584773757a1034af42cc2",
+      "original_sha256": "bd5479209fa7541cbc189c30ba3a91d47ee3dda7d57584773757a1034af42cc2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/diode.json": {
+      "export_sha256": "a223974ab82aff6a2ddad1a7864972b25d67060833a38a7090d3db82bf4257ca",
+      "original_sha256": "a223974ab82aff6a2ddad1a7864972b25d67060833a38a7090d3db82bf4257ca"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/eth3d.json": {
+      "export_sha256": "b6311545d9c7ca5b7581bad694d698b536a93d792390b1f088c49d4014006770",
+      "original_sha256": "b6311545d9c7ca5b7581bad694d698b536a93d792390b1f088c49d4014006770"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/gso.json": {
+      "export_sha256": "54e8f7bc4243541c42d79c5fbbf6f5e727b48d6633e73587978ec4ce43d241b9",
+      "original_sha256": "54e8f7bc4243541c42d79c5fbbf6f5e727b48d6633e73587978ec4ce43d241b9"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/hammer.json": {
+      "export_sha256": "aaf6ea2c6fc4a82b2c37428539c89d9dc18e77e481b9c78ab0f55826fdabb252",
+      "original_sha256": "aaf6ea2c6fc4a82b2c37428539c89d9dc18e77e481b9c78ab0f55826fdabb252"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/ibims-1.json": {
+      "export_sha256": "c56f2362c6bc08f5b91d627ce3a30f8cc71056d36707217aab9afbfdad33343b",
+      "original_sha256": "c56f2362c6bc08f5b91d627ce3a30f8cc71056d36707217aab9afbfdad33343b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/kitti.json": {
+      "export_sha256": "caf8893ff50bbeb7f8b1e41c524d07508ca88853c3dd6a8d184fe8bee1cd919e",
+      "original_sha256": "caf8893ff50bbeb7f8b1e41c524d07508ca88853c3dd6a8d184fe8bee1cd919e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/nyu.json": {
+      "export_sha256": "27764421867a97728a9fe03e543f78a27c372fce51487d72eadcc58ee73f6aa7",
+      "original_sha256": "27764421867a97728a9fe03e543f78a27c372fce51487d72eadcc58ee73f6aa7"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/sintel.json": {
+      "export_sha256": "e1db76f5e45a46676371d8dc05f753c5450723b7f240c5e51894312121832881",
+      "original_sha256": "e1db76f5e45a46676371d8dc05f753c5450723b7f240c5e51894312121832881"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/eval/benchmarks/spring.json": {
+      "export_sha256": "e8a474ab587994161ec7391f55c667c52d10e8f590bca782f13fabc857eef92a",
+      "original_sha256": "e8a474ab587994161ec7391f55c667c52d10e8f590bca782f13fabc857eef92a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/train/v1.json": {
+      "export_sha256": "87f8f091ac74b45cfc77137e768cbe52c7e13eb989492652b82ac529cf939375",
+      "original_sha256": "87f8f091ac74b45cfc77137e768cbe52c7e13eb989492652b82ac529cf939375"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/configs/train/v2.json": {
+      "export_sha256": "dccee76a670f09ceafe47d79b6122799af3a35496d18b69539a841794aa8c5bb",
+      "original_sha256": "dccee76a670f09ceafe47d79b6122799af3a35496d18b69539a841794aa8c5bb"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge.egg-info/SOURCES.txt": {
+      "export_sha256": "a763a0133f51cf48294d053cca20d8a937977109404644def6f9540285a343a9",
+      "original_sha256": "a763a0133f51cf48294d053cca20d8a937977109404644def6f9540285a343a9"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge.egg-info/dependency_links.txt": {
+      "export_sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+      "original_sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge.egg-info/entry_points.txt": {
+      "export_sha256": "ac7e9a507d39ea8d2caae3fa55dd7dfa8f2b24f497e9313034f96b5ea60816aa",
+      "original_sha256": "ac7e9a507d39ea8d2caae3fa55dd7dfa8f2b24f497e9313034f96b5ea60816aa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge.egg-info/requires.txt": {
+      "export_sha256": "40c80ddac88311c1dbc2228c9a641a413d26cdf91de5fa806f45225a7b3817ff",
+      "original_sha256": "40c80ddac88311c1dbc2228c9a641a413d26cdf91de5fa806f45225a7b3817ff"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge.egg-info/top_level.txt": {
+      "export_sha256": "fb31d43ccefcd8515f36d3a74a97986acf0b1319b9d1eae644900c6b566da6e8",
+      "original_sha256": "fb31d43ccefcd8515f36d3a74a97986acf0b1319b9d1eae644900c6b566da6e8"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/__init__.py": {
+      "export_sha256": "8cf7085951f070021c3e212f35570d924aaa85e98002c285bc7c1df917d36294",
+      "original_sha256": "8cf7085951f070021c3e212f35570d924aaa85e98002c285bc7c1df917d36294"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/__init__.py": {
+      "export_sha256": "0d2b87b7e71c7f7279ccc4b4f8b541d26071425284a0ea01a5a435fac4511cfe",
+      "original_sha256": "0d2b87b7e71c7f7279ccc4b4f8b541d26071425284a0ea01a5a435fac4511cfe"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/hub/__init__.py": {
+      "export_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f",
+      "original_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/hub/backbones.py": {
+      "export_sha256": "11c3b7e3da2a843ba5953191e8fc2027b37490313dfb315c0d4ad1a0ea31d27d",
+      "original_sha256": "11c3b7e3da2a843ba5953191e8fc2027b37490313dfb315c0d4ad1a0ea31d27d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/hub/utils.py": {
+      "export_sha256": "c0533919016531b320bf9aef7cd7001249bc8ef8957cdb29246c15b67d5abdf8",
+      "original_sha256": "c0533919016531b320bf9aef7cd7001249bc8ef8957cdb29246c15b67d5abdf8"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/__init__.py": {
+      "export_sha256": "5b5f637b2371089e34e0bec9a49518e2250f915aa9e10cae83a32f8e671ad24f",
+      "original_sha256": "5b5f637b2371089e34e0bec9a49518e2250f915aa9e10cae83a32f8e671ad24f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/attention.py": {
+      "export_sha256": "cc3f20ec18a07061297bcbeacc842aec43534f8eb5fd62516273c2c3385a6b79",
+      "original_sha256": "cc3f20ec18a07061297bcbeacc842aec43534f8eb5fd62516273c2c3385a6b79"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/block.py": {
+      "export_sha256": "13a024d6b45dd0c63300f0ef0b5135d8551dc563436c4d70fc4ec7c44980023b",
+      "original_sha256": "13a024d6b45dd0c63300f0ef0b5135d8551dc563436c4d70fc4ec7c44980023b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/dino_head.py": {
+      "export_sha256": "9fdb1fa61c0609dc0876f711f9d0d828c33bf9fd972aab3d9c968d44e16b98d1",
+      "original_sha256": "9fdb1fa61c0609dc0876f711f9d0d828c33bf9fd972aab3d9c968d44e16b98d1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/drop_path.py": {
+      "export_sha256": "b9f8236e86054b9d9a71275efcad2a9ecaa1f86b529d4b8d6109ddb5e806f67a",
+      "original_sha256": "b9f8236e86054b9d9a71275efcad2a9ecaa1f86b529d4b8d6109ddb5e806f67a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/layer_scale.py": {
+      "export_sha256": "abb7bbfae152a9de2e6d0961ab5e75c79428e849281bfe50dd07b66b54b485d1",
+      "original_sha256": "abb7bbfae152a9de2e6d0961ab5e75c79428e849281bfe50dd07b66b54b485d1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/mlp.py": {
+      "export_sha256": "255825c73b60a916dd00eb1e38aacbcdbf316e40d6a005efb46e245b7edb43aa",
+      "original_sha256": "255825c73b60a916dd00eb1e38aacbcdbf316e40d6a005efb46e245b7edb43aa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/patch_embed.py": {
+      "export_sha256": "40da6add3d811198ea3e17cb99cdd4e5cda59e369efbbe3d18d89308618cf142",
+      "original_sha256": "40da6add3d811198ea3e17cb99cdd4e5cda59e369efbbe3d18d89308618cf142"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/layers/swiglu_ffn.py": {
+      "export_sha256": "4c75f68d902cf497cb51e770ab8720057fa9957dd4c93da83aaf4f8893d14538",
+      "original_sha256": "4c75f68d902cf497cb51e770ab8720057fa9957dd4c93da83aaf4f8893d14538"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/models/__init__.py": {
+      "export_sha256": "87b360c71997314f41be1c497cc42326fc32617d3a2840f2f19d3795ca8b85ee",
+      "original_sha256": "87b360c71997314f41be1c497cc42326fc32617d3a2840f2f19d3795ca8b85ee"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/models/vision_transformer.py": {
+      "export_sha256": "1df8a949cf9e7eb3e1e4721f3a82839a0685b9dc94c52a5f5a9ab6ee9ffb0cd0",
+      "original_sha256": "1df8a949cf9e7eb3e1e4721f3a82839a0685b9dc94c52a5f5a9ab6ee9ffb0cd0"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/utils/__init__.py": {
+      "export_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f",
+      "original_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/utils/cluster.py": {
+      "export_sha256": "ea195476b1f5316520c07233eb73ff4b0e5fe3f7a2645aacec5b416e7bed157c",
+      "original_sha256": "ea195476b1f5316520c07233eb73ff4b0e5fe3f7a2645aacec5b416e7bed157c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/utils/config.py": {
+      "export_sha256": "588574a78951ccfe7ffaad9ef7cab53d37e837e3ae98cfc1b6a976189073d87c",
+      "original_sha256": "588574a78951ccfe7ffaad9ef7cab53d37e837e3ae98cfc1b6a976189073d87c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/utils/dtype.py": {
+      "export_sha256": "610251537bcf55de8961a17dd625560eae5cfa5082e9382bbd9ded86db92e1c6",
+      "original_sha256": "610251537bcf55de8961a17dd625560eae5cfa5082e9382bbd9ded86db92e1c6"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/utils/param_groups.py": {
+      "export_sha256": "ec1daae9eb7c50492091504f97087e3179d46a080d7b7f131967c07cb15cf6d4",
+      "original_sha256": "ec1daae9eb7c50492091504f97087e3179d46a080d7b7f131967c07cb15cf6d4"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/dinov2/utils/utils.py": {
+      "export_sha256": "10bfc824fdb00cf0c4afc0a875b5763ad4c5f33ec38c2515b12528307b789305",
+      "original_sha256": "10bfc824fdb00cf0c4afc0a875b5763ad4c5f33ec38c2515b12528307b789305"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/modules.py": {
+      "export_sha256": "cb5d7ff75f410be2f8466fc5ca164e04f7b991385c141b3d896c02ead7858fc2",
+      "original_sha256": "cb5d7ff75f410be2f8466fc5ca164e04f7b991385c141b3d896c02ead7858fc2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/utils.py": {
+      "export_sha256": "cb7279c4295afae9278b13d70181128ab2e29027b08a012a1b0f33213c16de22",
+      "original_sha256": "cb7279c4295afae9278b13d70181128ab2e29027b08a012a1b0f33213c16de22"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/v1.py": {
+      "export_sha256": "a6c030f2e93e3c02268dc6d523a33d74299b6d012c3c2bf34c7e7c4a44646241",
+      "original_sha256": "a6c030f2e93e3c02268dc6d523a33d74299b6d012c3c2bf34c7e7c4a44646241"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/model/v2.py": {
+      "export_sha256": "e736ed59fdb8ad89ec0c29ddfeeccd6a4246c387b3f423b922708366b69758fd",
+      "original_sha256": "e736ed59fdb8ad89ec0c29ddfeeccd6a4246c387b3f423b922708366b69758fd"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/app.py": {
+      "export_sha256": "8ea56be9dbcfaec9dd6a0f41f670e140a3a6f71f48f8e85a3e4eb7232be2e0ba",
+      "original_sha256": "8ea56be9dbcfaec9dd6a0f41f670e140a3a6f71f48f8e85a3e4eb7232be2e0ba"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/cli.py": {
+      "export_sha256": "86419e34bbfd15d0646b1d3821fa68651cb21f316428be862ed1df0a126395d0",
+      "original_sha256": "86419e34bbfd15d0646b1d3821fa68651cb21f316428be862ed1df0a126395d0"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/eval_baseline.py": {
+      "export_sha256": "17702081385cc1221e7ad04d57fbcabb687d1d9705a63011f20c0626b826f3fe",
+      "original_sha256": "17702081385cc1221e7ad04d57fbcabb687d1d9705a63011f20c0626b826f3fe"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/infer.py": {
+      "export_sha256": "76b59a7edbb63748ee028f5479aa2ee8beecae4b0e8d240b2166e4207d4e1649",
+      "original_sha256": "76b59a7edbb63748ee028f5479aa2ee8beecae4b0e8d240b2166e4207d4e1649"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/infer_baseline.py": {
+      "export_sha256": "dfc2ff6b161dceceeeecc31456e9e4ac534de3d0457954cea375ba061e27fbb2",
+      "original_sha256": "dfc2ff6b161dceceeeecc31456e9e4ac534de3d0457954cea375ba061e27fbb2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/infer_panorama.py": {
+      "export_sha256": "fddd6f0112dbcb91c10c2a3909a6e3c4367dd1b4466c1ed0f283b3a20171251f",
+      "original_sha256": "fddd6f0112dbcb91c10c2a3909a6e3c4367dd1b4466c1ed0f283b3a20171251f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/train.py": {
+      "export_sha256": "969c12ce3be0a70183da7f6015c3d80ee9cb5c6d92a944b4d662b3e3527f06cd",
+      "original_sha256": "969c12ce3be0a70183da7f6015c3d80ee9cb5c6d92a944b4d662b3e3527f06cd"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/scripts/vis_data.py": {
+      "export_sha256": "5f19d6ea30bc4b76fe8ccb1a71423b65bd15b262fc9d3356150c98098464483c",
+      "original_sha256": "5f19d6ea30bc4b76fe8ccb1a71423b65bd15b262fc9d3356150c98098464483c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/test/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/test/baseline.py": {
+      "export_sha256": "8f62da7022ab16f3f00556ac38580f085c68477d9200722646c77a78720a0d75",
+      "original_sha256": "8f62da7022ab16f3f00556ac38580f085c68477d9200722646c77a78720a0d75"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/test/dataloader.py": {
+      "export_sha256": "086974ff7f31378e202a187a73e4224db058fe834de34027850f04871672c60e",
+      "original_sha256": "086974ff7f31378e202a187a73e4224db058fe834de34027850f04871672c60e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/test/metrics.py": {
+      "export_sha256": "f581a2cf1d625127e644f4648d7e8d6414ba3ae0792dc18e3a076ba1e0a4acbf",
+      "original_sha256": "f581a2cf1d625127e644f4648d7e8d6414ba3ae0792dc18e3a076ba1e0a4acbf"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/train/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/train/dataloader.py": {
+      "export_sha256": "0da45febd0e798de25828ee44ff38a5c9a4bad98c9db07796dce3eb10e45c210",
+      "original_sha256": "0da45febd0e798de25828ee44ff38a5c9a4bad98c9db07796dce3eb10e45c210"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/train/losses.py": {
+      "export_sha256": "05c090c901e038be389df4cee04dea05444f5c6f2ff4dce9bfc76fe761c7c325",
+      "original_sha256": "05c090c901e038be389df4cee04dea05444f5c6f2ff4dce9bfc76fe761c7c325"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/train/utils.py": {
+      "export_sha256": "97b645e3789cb4739ef87437313405b6b0b2dc04e745ae99f3bc987a3b22e723",
+      "original_sha256": "97b645e3789cb4739ef87437313405b6b0b2dc04e745ae99f3bc987a3b22e723"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/alignment.py": {
+      "export_sha256": "85f65b3648a557fd39e76014503a892b2aceea7cd5e0471a1de1def68f0c31e1",
+      "original_sha256": "85f65b3648a557fd39e76014503a892b2aceea7cd5e0471a1de1def68f0c31e1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/data_augmentation.py": {
+      "export_sha256": "c86762cf72aa07d59a75da42d8d0f2dd45bfd9b1eed14bbed8d05da15f8e8bbd",
+      "original_sha256": "c86762cf72aa07d59a75da42d8d0f2dd45bfd9b1eed14bbed8d05da15f8e8bbd"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/download.py": {
+      "export_sha256": "929fde9df713247927b93807809ffa9b5a49572d6bd5bd1ae57235d2c8f4fc91",
+      "original_sha256": "929fde9df713247927b93807809ffa9b5a49572d6bd5bd1ae57235d2c8f4fc91"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/geometry_numpy.py": {
+      "export_sha256": "f540c5b8ef55bfffcc32b1a62b38be605683e29fbf399ca86dfcbfc458ce4c10",
+      "original_sha256": "f540c5b8ef55bfffcc32b1a62b38be605683e29fbf399ca86dfcbfc458ce4c10"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/geometry_torch.py": {
+      "export_sha256": "2f8d5de7d671af16d25fe13c555fd73855d8447bc086bb23aa42e859b303fb05",
+      "original_sha256": "2f8d5de7d671af16d25fe13c555fd73855d8447bc086bb23aa42e859b303fb05"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/io.py": {
+      "export_sha256": "36dcbc1fc933dcd19d2c97d3a7a3d556ce3f3a191055bb4cc6f93168c4ef32ba",
+      "original_sha256": "36dcbc1fc933dcd19d2c97d3a7a3d556ce3f3a191055bb4cc6f93168c4ef32ba"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/panorama.py": {
+      "export_sha256": "861e747f6fa5d9c855cd4e9d7964165a6d3e3e73f81ad78d6dfe98f6b6d70d8d",
+      "original_sha256": "861e747f6fa5d9c855cd4e9d7964165a6d3e3e73f81ad78d6dfe98f6b6d70d8d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/tools.py": {
+      "export_sha256": "ee4893ddbc49da5b24ab43277e9693e86a842dace69452803bab85b531121f60",
+      "original_sha256": "ee4893ddbc49da5b24ab43277e9693e86a842dace69452803bab85b531121f60"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/vis.py": {
+      "export_sha256": "eb4d3d9a77caf923628312ab56e5fc241f39a2d3f2c066a763e76ce49842c1a9",
+      "original_sha256": "eb4d3d9a77caf923628312ab56e5fc241f39a2d3f2c066a763e76ce49842c1a9"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/webfile.py": {
+      "export_sha256": "3ffcd69e343b9c867cf52c80ec1923f76478a6e8bda712cc677bfefb077b0777",
+      "original_sha256": "3ffcd69e343b9c867cf52c80ec1923f76478a6e8bda712cc677bfefb077b0777"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/moge/utils/webzipfile.py": {
+      "export_sha256": "5e68057dad8f05ecbd08883f2b960211512c28bdb0243d32700ec5102b735668",
+      "original_sha256": "5e68057dad8f05ecbd08883f2b960211512c28bdb0243d32700ec5102b735668"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/pyproject.toml": {
+      "export_sha256": "1c1c41fc449cee5e30cb02c36d4c7b208812f48739e7bcfdffc5a22207f1a3c2",
+      "original_sha256": "1c1c41fc449cee5e30cb02c36d4c7b208812f48739e7bcfdffc5a22207f1a3c2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/pyrightconfig.json": {
+      "export_sha256": "b2b2dc093467b72670b2df73dd4e3263c59d6b8aa131cd327438790a57ec4e45",
+      "original_sha256": "b2b2dc093467b72670b2df73dd4e3263c59d6b8aa131cd327438790a57ec4e45"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/MoGe/requirements.txt": {
+      "export_sha256": "aff0d7e9df26146afdcd0e7a4a30d967fd07a8da25c30be0737607b414a81a17",
+      "original_sha256": "aff0d7e9df26146afdcd0e7a4a30d967fd07a8da25c30be0737607b414a81a17"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/align_heads/__init_.py": {
+      "export_sha256": "3ee313b0fea665d122e54af056dfa3f8ef21528ffa08f23735aa91296c56b007",
+      "original_sha256": "3ee313b0fea665d122e54af056dfa3f8ef21528ffa08f23735aa91296c56b007"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/align_heads/depth_head.py": {
+      "export_sha256": "78d3a617b8b84647ee3811c606f6554d40efadd5ff330d5efc91a64af919fd79",
+      "original_sha256": "78d3a617b8b84647ee3811c606f6554d40efadd5ff330d5efc91a64af919fd79"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/align_heads/resampler.py": {
+      "export_sha256": "21e8444e7af259746c7786ec0064e8325b446305677fffebcc9569d749549ab8",
+      "original_sha256": "21e8444e7af259746c7786ec0064e8325b446305677fffebcc9569d749549ab8"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/__init__.py": {
+      "export_sha256": "83824d4d91b800227e03562bf303d1e3758582efa6af9d9fb3898a971a21e807",
+      "original_sha256": "83824d4d91b800227e03562bf303d1e3758582efa6af9d9fb3898a971a21e807"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/__init__.py": {
+      "export_sha256": "94df78b000730b9534e7f575731bf4d1668eba5fa6ef693f57dd25dafc3572ce",
+      "original_sha256": "94df78b000730b9534e7f575731bf4d1668eba5fa6ef693f57dd25dafc3572ce"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/__init__.py": {
+      "export_sha256": "b745baf826d0df619d7eaaf1d6fdd9c04e2cf87a2e74abad1ca37e435757a894",
+      "original_sha256": "b745baf826d0df619d7eaaf1d6fdd9c04e2cf87a2e74abad1ca37e435757a894"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/attention.py": {
+      "export_sha256": "26d9ca3a0a9848dfe0da1221d4d0b902b0f63aa18c6e3bb75cf7bf9b6928d67e",
+      "original_sha256": "26d9ca3a0a9848dfe0da1221d4d0b902b0f63aa18c6e3bb75cf7bf9b6928d67e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/block.py": {
+      "export_sha256": "9ad2173e78d4037aebe7e6ef3a8c64e7f3b08fc8f888eda9e6e62ee92805b0d6",
+      "original_sha256": "9ad2173e78d4037aebe7e6ef3a8c64e7f3b08fc8f888eda9e6e62ee92805b0d6"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/dino_head.py": {
+      "export_sha256": "cd7a83f00ac449f962484bad0f2959be477781e57943508428d32ff88f41fe33",
+      "original_sha256": "cd7a83f00ac449f962484bad0f2959be477781e57943508428d32ff88f41fe33"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/ffn_layers.py": {
+      "export_sha256": "29d3f20800e9bcf5fa4e056f6b0e81c1375c291c1dbffd5b103ac555fe2cb9ff",
+      "original_sha256": "29d3f20800e9bcf5fa4e056f6b0e81c1375c291c1dbffd5b103ac555fe2cb9ff"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/flash_attention.py": {
+      "export_sha256": "6f664bc7bc9f9e38e955c7fac07eea5cb236e869b00584ca9b263d11c8f890ad",
+      "original_sha256": "6f664bc7bc9f9e38e955c7fac07eea5cb236e869b00584ca9b263d11c8f890ad"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/flash_attention_packed.py": {
+      "export_sha256": "2a8776749e7c0d6dd780a67764f8e51cc90b0f417cd53aec7422cf07f8712a6d",
+      "original_sha256": "2a8776749e7c0d6dd780a67764f8e51cc90b0f417cd53aec7422cf07f8712a6d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/flex_attention_packed.py": {
+      "export_sha256": "177f4ffdb522e861677e1178abc2cc114d3bf41d62b690c9baa2fd37dd8d2820",
+      "original_sha256": "177f4ffdb522e861677e1178abc2cc114d3bf41d62b690c9baa2fd37dd8d2820"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/layer_scale.py": {
+      "export_sha256": "f9a10ee763a62136f9e814bfe2f2209c2cb501dfdc5573f858ab01ba9a69c23f",
+      "original_sha256": "f9a10ee763a62136f9e814bfe2f2209c2cb501dfdc5573f858ab01ba9a69c23f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/patch_embed.py": {
+      "export_sha256": "88ceaac1439a54a6553a5ca8e7d97c40f92747e9edc64f5680afd21af7299475",
+      "original_sha256": "88ceaac1439a54a6553a5ca8e7d97c40f92747e9edc64f5680afd21af7299475"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/rms_norm.py": {
+      "export_sha256": "8509ffc53f0bbe9e353a8b9e57ca2396795640b4ecc85140c27b17127c971869",
+      "original_sha256": "8509ffc53f0bbe9e353a8b9e57ca2396795640b4ecc85140c27b17127c971869"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/rope_position_encoding.py": {
+      "export_sha256": "5236c6fb9d84252655b1a60a7177db5e6cf4a3c15227e49f4959d32947b4ba2e",
+      "original_sha256": "5236c6fb9d84252655b1a60a7177db5e6cf4a3c15227e49f4959d32947b4ba2e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/layers/sdpa_attention_packed.py": {
+      "export_sha256": "e062fe9c9df49330a54bd9922206a8b66fbd8753c61ce2d0ed3d5b3df4580bce",
+      "original_sha256": "e062fe9c9df49330a54bd9922206a8b66fbd8753c61ce2d0ed3d5b3df4580bce"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/__init__.py": {
+      "export_sha256": "1faa23c982cbfcd019e3bbc92021a79123e6ff802c70c618470681068652af5c",
+      "original_sha256": "1faa23c982cbfcd019e3bbc92021a79123e6ff802c70c618470681068652af5c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/inference/__init__.py": {
+      "export_sha256": "75940a6a6035f3fc4cebcd5a0cb8800e1f5bd82547e0ec7cc9463d9774c149b2",
+      "original_sha256": "75940a6a6035f3fc4cebcd5a0cb8800e1f5bd82547e0ec7cc9463d9774c149b2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/inference/causal_eval.py": {
+      "export_sha256": "c754df45a6113d4ddd6aa6d1527ab4587d4efb35b1906eeb6ef7480bd7da04bc",
+      "original_sha256": "c754df45a6113d4ddd6aa6d1527ab4587d4efb35b1906eeb6ef7480bd7da04bc"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/inference/kv_cache.py": {
+      "export_sha256": "3d186623252f18d240bf71622127622da5b2ccea15040c92b6109b03ab54e965",
+      "original_sha256": "3d186623252f18d240bf71622127622da5b2ccea15040c92b6109b03ab54e965"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/navit_eval.py": {
+      "export_sha256": "1fafad9450f0e5a53328cddc066cc37d71db9bbc2e3222dfabed05b4fb6a774e",
+      "original_sha256": "1fafad9450f0e5a53328cddc066cc37d71db9bbc2e3222dfabed05b4fb6a774e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/navit_video_vision_transformer.py": {
+      "export_sha256": "4a3a1bd606c2f639edf418a4ead0864882b152f4c815956baa245c890a5fc503",
+      "original_sha256": "4a3a1bd606c2f639edf418a4ead0864882b152f4c815956baa245c890a5fc503"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/unified_video_vision_transformer.py": {
+      "export_sha256": "d50e23815d713e77eadf796cb1051a3051a5e38be20689b26e9e4927c3c64a2f",
+      "original_sha256": "d50e23815d713e77eadf796cb1051a3051a5e38be20689b26e9e4927c3c64a2f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/models/vision_transformer.py": {
+      "export_sha256": "a04ac7f1393e8992bbfc8e8460c59d24e26c65c410baccbdbe90f605d98c3ba9",
+      "original_sha256": "a04ac7f1393e8992bbfc8e8460c59d24e26c65c410baccbdbe90f605d98c3ba9"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/lumos_dinov3/utils.py": {
+      "export_sha256": "0e9422435fc9fc6a885800527b76476c22709852fb492b4b0f9705a93a4ebe2f",
+      "original_sha256": "0e9422435fc9fc6a885800527b76476c22709852fb492b4b0f9705a93a4ebe2f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/dino_video/teacher.py": {
+      "export_sha256": "1aa25aca20347d7dca2d265ab377e6b2f8f3b36485422cfc6d6c4a9d503f63b5",
+      "original_sha256": "1aa25aca20347d7dca2d265ab377e6b2f8f3b36485422cfc6d6c4a9d503f63b5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/LICENSE": {
+      "export_sha256": "56ae0eb5ff848e312f8ecc450c806f710821db153b0e8db18a0d69d5a6f60f8b",
+      "original_sha256": "56ae0eb5ff848e312f8ecc450c806f710821db153b0e8db18a0d69d5a6f60f8b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/example.py": {
+      "export_sha256": "ed5bc3807bba81be71f3b7d978e0e38100acc3c0d94fe254b2dfcabd45210795",
+      "original_sha256": "ed5bc3807bba81be71f3b7d978e0e38100acc3c0d94fe254b2dfcabd45210795"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/0/intrinsics.txt": {
+      "export_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5",
+      "original_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/1/intrinsics.txt": {
+      "export_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f",
+      "original_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/2/intrinsics.txt": {
+      "export_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5",
+      "original_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/3/intrinsics.txt": {
+      "export_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f",
+      "original_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/4/intrinsics.txt": {
+      "export_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5",
+      "original_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/5/intrinsics.txt": {
+      "export_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5",
+      "original_sha256": "599fd7617e1225e289fdbc4dec835d55ccb6577b83953b02ce89a53f3bf237d5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/6/intrinsics.txt": {
+      "export_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f",
+      "original_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/examples/7/intrinsics.txt": {
+      "export_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f",
+      "original_sha256": "76b62be8b9969ed3787630ce12e6667e0e13811b8484e2b9b69936928d31bd0f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm.egg-info/SOURCES.txt": {
+      "export_sha256": "f0e6e7658cb18cc2097a72be3f8d2acb30ce954ce1d50f696112ec88bd3ba986",
+      "original_sha256": "f0e6e7658cb18cc2097a72be3f8d2acb30ce954ce1d50f696112ec88bd3ba986"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm.egg-info/dependency_links.txt": {
+      "export_sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+      "original_sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm.egg-info/requires.txt": {
+      "export_sha256": "3cf871b4192759af491804ebbae100ec2bea0643eacf998bc4463e5461246826",
+      "original_sha256": "3cf871b4192759af491804ebbae100ec2bea0643eacf998bc4463e5461246826"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm.egg-info/top_level.txt": {
+      "export_sha256": "e1c251886aa07f8ff3f8ca2a519fd01dc811ccadade001a038fd18f73c4bec16",
+      "original_sha256": "e1c251886aa07f8ff3f8ca2a519fd01dc811ccadade001a038fd18f73c4bec16"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/__init__.py": {
+      "export_sha256": "20466a32b5c18e07a2afc9c1793ca48123039ee7e1a46de37461fb153a8d3193",
+      "original_sha256": "20466a32b5c18e07a2afc9c1793ca48123039ee7e1a46de37461fb153a8d3193"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/__init__.py": {
+      "export_sha256": "0d2b87b7e71c7f7279ccc4b4f8b541d26071425284a0ea01a5a435fac4511cfe",
+      "original_sha256": "0d2b87b7e71c7f7279ccc4b4f8b541d26071425284a0ea01a5a435fac4511cfe"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/hub/__init__.py": {
+      "export_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f",
+      "original_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/hub/backbones.py": {
+      "export_sha256": "74b7f24365cfd454326c91f438c77a4d7f0c3fb2a424eb6a5d48d53573bbf54d",
+      "original_sha256": "74b7f24365cfd454326c91f438c77a4d7f0c3fb2a424eb6a5d48d53573bbf54d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/hub/utils.py": {
+      "export_sha256": "c0533919016531b320bf9aef7cd7001249bc8ef8957cdb29246c15b67d5abdf8",
+      "original_sha256": "c0533919016531b320bf9aef7cd7001249bc8ef8957cdb29246c15b67d5abdf8"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/__init__.py": {
+      "export_sha256": "29d808e091d40cfdb4d5a4355c3c0fc325353686e6b0b0b3f6a24676ca4afd78",
+      "original_sha256": "29d808e091d40cfdb4d5a4355c3c0fc325353686e6b0b0b3f6a24676ca4afd78"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/attention.py": {
+      "export_sha256": "cc3f20ec18a07061297bcbeacc842aec43534f8eb5fd62516273c2c3385a6b79",
+      "original_sha256": "cc3f20ec18a07061297bcbeacc842aec43534f8eb5fd62516273c2c3385a6b79"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/block.py": {
+      "export_sha256": "fe8ae374b8b08d634320ca4083cdc5f671926bcf7eb012e8988b83920b99ef58",
+      "original_sha256": "fe8ae374b8b08d634320ca4083cdc5f671926bcf7eb012e8988b83920b99ef58"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/dino_head.py": {
+      "export_sha256": "9fdb1fa61c0609dc0876f711f9d0d828c33bf9fd972aab3d9c968d44e16b98d1",
+      "original_sha256": "9fdb1fa61c0609dc0876f711f9d0d828c33bf9fd972aab3d9c968d44e16b98d1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/drop_path.py": {
+      "export_sha256": "b9f8236e86054b9d9a71275efcad2a9ecaa1f86b529d4b8d6109ddb5e806f67a",
+      "original_sha256": "b9f8236e86054b9d9a71275efcad2a9ecaa1f86b529d4b8d6109ddb5e806f67a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/layer_scale.py": {
+      "export_sha256": "abb7bbfae152a9de2e6d0961ab5e75c79428e849281bfe50dd07b66b54b485d1",
+      "original_sha256": "abb7bbfae152a9de2e6d0961ab5e75c79428e849281bfe50dd07b66b54b485d1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/mlp.py": {
+      "export_sha256": "255825c73b60a916dd00eb1e38aacbcdbf316e40d6a005efb46e245b7edb43aa",
+      "original_sha256": "255825c73b60a916dd00eb1e38aacbcdbf316e40d6a005efb46e245b7edb43aa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/patch_embed.py": {
+      "export_sha256": "40da6add3d811198ea3e17cb99cdd4e5cda59e369efbbe3d18d89308618cf142",
+      "original_sha256": "40da6add3d811198ea3e17cb99cdd4e5cda59e369efbbe3d18d89308618cf142"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/patch_embed_mlp.py": {
+      "export_sha256": "0c18967ba6195c7864c5a963b3c128f125daea7198a0a9e0fc2528eb3246f221",
+      "original_sha256": "0c18967ba6195c7864c5a963b3c128f125daea7198a0a9e0fc2528eb3246f221"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/layers/swiglu_ffn.py": {
+      "export_sha256": "4c75f68d902cf497cb51e770ab8720057fa9957dd4c93da83aaf4f8893d14538",
+      "original_sha256": "4c75f68d902cf497cb51e770ab8720057fa9957dd4c93da83aaf4f8893d14538"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/models/__init__.py": {
+      "export_sha256": "ed3430c69b7845b741ac3badc189e901a52a7d45a97d6aaa441b79be29734f8a",
+      "original_sha256": "ed3430c69b7845b741ac3badc189e901a52a7d45a97d6aaa441b79be29734f8a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/models/mask_utils.py": {
+      "export_sha256": "f7a7db258f0a29cae1077056c95010b14004952ba455ba7915c0f2bbbffe75f3",
+      "original_sha256": "f7a7db258f0a29cae1077056c95010b14004952ba455ba7915c0f2bbbffe75f3"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/models/vision_transformer.py": {
+      "export_sha256": "84e9883def1b61c62e438c4ee152c4425c9e7f8bba30cf655e6361eb684ba137",
+      "original_sha256": "84e9883def1b61c62e438c4ee152c4425c9e7f8bba30cf655e6361eb684ba137"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/utils/__init__.py": {
+      "export_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f",
+      "original_sha256": "2932e94a2d67be87b717c49468214c1127be7864aedf37f5891d26be7bc1437f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/utils/cluster.py": {
+      "export_sha256": "ea195476b1f5316520c07233eb73ff4b0e5fe3f7a2645aacec5b416e7bed157c",
+      "original_sha256": "ea195476b1f5316520c07233eb73ff4b0e5fe3f7a2645aacec5b416e7bed157c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/utils/config.py": {
+      "export_sha256": "588574a78951ccfe7ffaad9ef7cab53d37e837e3ae98cfc1b6a976189073d87c",
+      "original_sha256": "588574a78951ccfe7ffaad9ef7cab53d37e837e3ae98cfc1b6a976189073d87c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/utils/dtype.py": {
+      "export_sha256": "610251537bcf55de8961a17dd625560eae5cfa5082e9382bbd9ded86db92e1c6",
+      "original_sha256": "610251537bcf55de8961a17dd625560eae5cfa5082e9382bbd9ded86db92e1c6"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/utils/param_groups.py": {
+      "export_sha256": "ec1daae9eb7c50492091504f97087e3179d46a080d7b7f131967c07cb15cf6d4",
+      "original_sha256": "ec1daae9eb7c50492091504f97087e3179d46a080d7b7f131967c07cb15cf6d4"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/dinov2_rgbd/utils/utils.py": {
+      "export_sha256": "10bfc824fdb00cf0c4afc0a875b5763ad4c5f33ec38c2515b12528307b789305",
+      "original_sha256": "10bfc824fdb00cf0c4afc0a875b5763ad4c5f33ec38c2515b12528307b789305"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/modules_decoder.py": {
+      "export_sha256": "e809c6f5abb57061b58e43e50a04e20ac2179503abed02cafda3f82dfac7387e",
+      "original_sha256": "e809c6f5abb57061b58e43e50a04e20ac2179503abed02cafda3f82dfac7387e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/modules_rgbd_encoder.py": {
+      "export_sha256": "72f06b74ba10c39ae20b01154c8b0b108a17e47e0bb978563c80fc51fe5c46cd",
+      "original_sha256": "72f06b74ba10c39ae20b01154c8b0b108a17e47e0bb978563c80fc51fe5c46cd"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/utils.py": {
+      "export_sha256": "a7108de9525839a7277c6ce0db6d8108156739cb02571ad6a87eb822814204e6",
+      "original_sha256": "a7108de9525839a7277c6ce0db6d8108156739cb02571ad6a87eb822814204e6"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/model/v2.py": {
+      "export_sha256": "45f69b4e2c5fab73f883a2790a3c7839d7fd4c11c4d11343ef1d98b31be0351e",
+      "original_sha256": "45f69b4e2c5fab73f883a2790a3c7839d7fd4c11c4d11343ef1d98b31be0351e"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/utils/__init__.py": {
+      "export_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/utils/geo.py": {
+      "export_sha256": "b235df79d279a8ba0c1d62004df0a8af9a0c2a0faa4ebb52a0e7140f0541c8eb",
+      "original_sha256": "b235df79d279a8ba0c1d62004df0a8af9a0c2a0faa4ebb52a0e7140f0541c8eb"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/utils/io.py": {
+      "export_sha256": "b6907a108db83f8e40862c96ad089bc4d05dd88a630430b5c0f8c67ef5e1d20c",
+      "original_sha256": "b6907a108db83f8e40862c96ad089bc4d05dd88a630430b5c0f8c67ef5e1d20c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/utils/tools.py": {
+      "export_sha256": "ee4893ddbc49da5b24ab43277e9693e86a842dace69452803bab85b531121f60",
+      "original_sha256": "ee4893ddbc49da5b24ab43277e9693e86a842dace69452803bab85b531121f60"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/mdm/utils/vis.py": {
+      "export_sha256": "564fbb5898b6981c70fb3ce845b4ad1a1594360bd10787773ed194efa497c88a",
+      "original_sha256": "564fbb5898b6981c70fb3ce845b4ad1a1594360bd10787773ed194efa497c88a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/pyproject.toml": {
+      "export_sha256": "ead97cc2acc436b7f8dc538c634a1937a85ea89fb2202fa9c1ec8a812a807bfa",
+      "original_sha256": "ead97cc2acc436b7f8dc538c634a1937a85ea89fb2202fa9c1ec8a812a807bfa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/pyrightconfig.json": {
+      "export_sha256": "57b08f87f3296e2675929e0202ba868921ab289cb264d417faf1f93ebf88f57b",
+      "original_sha256": "57b08f87f3296e2675929e0202ba868921ab289cb264d417faf1f93ebf88f57b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/lingbot-depth/requirements.txt": {
+      "export_sha256": "08e5c1253755a68475afc63e692510c1bbbcbaaa5d758eef1584bc40a455ccb4",
+      "original_sha256": "08e5c1253755a68475afc63e692510c1bbbcbaaa5d758eef1584bc40a455ccb4"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/models/vla/vision_models/module_utils.py": {
+      "export_sha256": "3d7cc8834d949c193f80add5ce2f031ec08e32312c895de07c68144c4bdc77aa",
+      "original_sha256": "3d7cc8834d949c193f80add5ce2f031ec08e32312c895de07c68144c4bdc77aa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/__init__.py": {
+      "export_sha256": "3935848ce37fb4598a1d091bc7162d17ff81df1bfb445bed4e8fc25bef705cc1",
+      "original_sha256": "3935848ce37fb4598a1d091bc7162d17ff81df1bfb445bed4e8fc25bef705cc1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/attention.py": {
+      "export_sha256": "1e89c4bd5112687e76f2e7a45971672b428fa2d5ff70c4979142feea1bc177c1",
+      "original_sha256": "1e89c4bd5112687e76f2e7a45971672b428fa2d5ff70c4979142feea1bc177c1"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/dit/rope_wan/rotary.py": {
+      "export_sha256": "b8231dbea9fdbe268375bd0b18cc2b5ba932c27d0bba089fa31f88d5eb1f1aab",
+      "original_sha256": "b8231dbea9fdbe268375bd0b18cc2b5ba932c27d0bba089fa31f88d5eb1f1aab"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/fused_moe.py": {
+      "export_sha256": "241f57de1f0745f86ba8620925b1bf6df9ac2753d867441b4b6da653404711ac",
+      "original_sha256": "241f57de1f0745f86ba8620925b1bf6df9ac2753d867441b4b6da653404711ac"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/group_gemm.py": {
+      "export_sha256": "06d45d9be527a9def13e385297b8444b19ea2d75da58ae769ed838f6539a3d4b",
+      "original_sha256": "06d45d9be527a9def13e385297b8444b19ea2d75da58ae769ed838f6539a3d4b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/moe.py": {
+      "export_sha256": "e2392e269128d440b79f98415ff1ebd6045e015fd17513c68462787653b442a7",
+      "original_sha256": "e2392e269128d440b79f98415ff1ebd6045e015fd17513c68462787653b442a7"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/triton_utils/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/triton_utils/activation.py": {
+      "export_sha256": "19c183fe5bd29444586a54a129414d5f4b79ebba0e58c0b5e4cafee75cf84137",
+      "original_sha256": "19c183fe5bd29444586a54a129414d5f4b79ebba0e58c0b5e4cafee75cf84137"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/triton_utils/memory.py": {
+      "export_sha256": "070d0de9c420c44daf4b423cccb2b5bd144b1fb5137142b7b84e7db32d7d5b56",
+      "original_sha256": "070d0de9c420c44daf4b423cccb2b5bd144b1fb5137142b7b84e7db32d7d5b56"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/kernel/triton_utils/utils.py": {
+      "export_sha256": "09e7d34dd88216694d07692df80e6db8611aa24df9563c3c024b50af61ec2d12",
+      "original_sha256": "09e7d34dd88216694d07692df80e6db8611aa24df9563c3c024b50af61ec2d12"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/benchmark_utils.py": {
+      "export_sha256": "97d9558b56c3ee0e1990fb24d8fe31e56dfa0aa50cc8d05569ae8b905a57d975",
+      "original_sha256": "97d9558b56c3ee0e1990fb24d8fe31e56dfa0aa50cc8d05569ae8b905a57d975"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/config.py": {
+      "export_sha256": "d6a79bb8b43c87b68cf6dafebeed30382e2935c3771a4a7c930245ce860abe9a",
+      "original_sha256": "d6a79bb8b43c87b68cf6dafebeed30382e2935c3771a4a7c930245ce860abe9a"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/device.py": {
+      "export_sha256": "b6c0b0815f251d6d45ef85c546372cea75ae836d6070e3117641afaab1e55eb2",
+      "original_sha256": "b6c0b0815f251d6d45ef85c546372cea75ae836d6070e3117641afaab1e55eb2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/envvars.py": {
+      "export_sha256": "2c0e816a20c5d0cfccf1497c50a78203c7aecc51fb4a08eefafaa33b2f22e8d7",
+      "original_sha256": "2c0e816a20c5d0cfccf1497c50a78203c7aecc51fb4a08eefafaa33b2f22e8d7"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/kernel.py": {
+      "export_sha256": "261363ce167e5dfc4e66a5a86bc7c24d6d36ff94c83f421050b98a7455a9b20d",
+      "original_sha256": "261363ce167e5dfc4e66a5a86bc7c24d6d36ff94c83f421050b98a7455a9b20d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/path.py": {
+      "export_sha256": "82100f20fdf6aa4455dde917606e2f2b36fc062ff23db59f0f4aad01e7751d2d",
+      "original_sha256": "82100f20fdf6aa4455dde917606e2f2b36fc062ff23db59f0f4aad01e7751d2d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/group_gemm/utils/pretuned.py": {
+      "export_sha256": "7b09a5353a92c54d49911b96d042545a0143f83e02448f964755d30d0dbe0ba5",
+      "original_sha256": "7b09a5353a92c54d49911b96d042545a0143f83e02448f964755d30d0dbe0ba5"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/loss.py": {
+      "export_sha256": "c8ed3b1cd2d7eb6246fa126a2ba2cd03a1c15eb4ff038083e0ee32e0759b7b89",
+      "original_sha256": "c8ed3b1cd2d7eb6246fa126a2ba2cd03a1c15eb4ff038083e0ee32e0759b7b89"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/moe_loss.py": {
+      "export_sha256": "9d3908b76a0becb7164890beb4ed409ea16b27cdafb7503b70debb3d42f1629b",
+      "original_sha256": "9d3908b76a0becb7164890beb4ed409ea16b27cdafb7503b70debb3d42f1629b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/robby_moe.py": {
+      "export_sha256": "56eb2c94987389517431e39cb4b4470967e96ff995713d9031b00b8607db1512",
+      "original_sha256": "56eb2c94987389517431e39cb4b4470967e96ff995713d9031b00b8607db1512"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/ops/triton_moe_loss.py": {
+      "export_sha256": "614a405e42722d7f77ba5f2183f254a0d2e15a0949ed974ffba70ef41a9faf8c",
+      "original_sha256": "614a405e42722d7f77ba5f2183f254a0d2e15a0949ed974ffba70ef41a9faf8c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/optim/__init__.py": {
+      "export_sha256": "0b627de37b350c267f2efe5074b1659fa4c305fe2f1329b7e7b219b1d7636dba",
+      "original_sha256": "0b627de37b350c267f2efe5074b1659fa4c305fe2f1329b7e7b219b1d7636dba"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/optim/lr_scheduler.py": {
+      "export_sha256": "fd1ace611797fb7ee9b33e6b293b0c2154fb18e4744fb77cde0c2e8381c283d2",
+      "original_sha256": "fd1ace611797fb7ee9b33e6b293b0c2154fb18e4744fb77cde0c2e8381c283d2"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/optim/muon.py": {
+      "export_sha256": "2ca3fcce6c158ed0dbf726313cb623520b13ff249d4ff83a98d6c3a4a6b47881",
+      "original_sha256": "2ca3fcce6c158ed0dbf726313cb623520b13ff249d4ff83a98d6c3a4a6b47881"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/optim/optimizer.py": {
+      "export_sha256": "88886197cc7aa2c3470ac4ba139c5ad5cc40f483c7dc61e3333611b0f577f733",
+      "original_sha256": "88886197cc7aa2c3470ac4ba139c5ad5cc40f483c7dc61e3333611b0f577f733"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/schedulers/flow_match.py": {
+      "export_sha256": "5a1d3ac920ea1b3b7fe1ee4027c46833c03d5a48f099d2f9bce0a054f9448d6d",
+      "original_sha256": "5a1d3ac920ea1b3b7fe1ee4027c46833c03d5a48f099d2f9bce0a054f9448d6d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/__init__.py": {
+      "export_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921",
+      "original_sha256": "ced14be479d27e864cf3557c37d8abe00d2204ba6c030620bf48ea85e25a5921"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/arguments.py": {
+      "export_sha256": "c4626c50c8287e31629b05479087e3653edec2fa05eb6cf5eca483e9506d7b22",
+      "original_sha256": "c4626c50c8287e31629b05479087e3653edec2fa05eb6cf5eca483e9506d7b22"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/async_hf_checkpoint.py": {
+      "export_sha256": "bb442489f8bdbc8f916bbe3694dc9eea8570abf48668e8eb30cc98fdaabc679b",
+      "original_sha256": "bb442489f8bdbc8f916bbe3694dc9eea8570abf48668e8eb30cc98fdaabc679b"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/async_tb_writer.py": {
+      "export_sha256": "f920b4532bc7d37523c266fe4dd82ca1a8ca1d166b393c04830c43092d75b8ac",
+      "original_sha256": "f920b4532bc7d37523c266fe4dd82ca1a8ca1d166b393c04830c43092d75b8ac"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/count_flops.py": {
+      "export_sha256": "fc5c198a1705d30eb93067ac8302acda981bc8c5c3b1cb8c0c6a9797b8b5780c",
+      "original_sha256": "fc5c198a1705d30eb93067ac8302acda981bc8c5c3b1cb8c0c6a9797b8b5780c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/depth_teacher_batch.py": {
+      "export_sha256": "b81d1f3acb3036ce7c6b7fd3137ac601bfe37a0733f4994c254094fe0d1bba5f",
+      "original_sha256": "b81d1f3acb3036ce7c6b7fd3137ac601bfe37a0733f4994c254094fe0d1bba5f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/dist_utils.py": {
+      "export_sha256": "2fe84232343bc18e6cee980aa2d0531bb58805c3a05493707ea691c6b90cc3aa",
+      "original_sha256": "2fe84232343bc18e6cee980aa2d0531bb58805c3a05493707ea691c6b90cc3aa"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/dit_utils.py": {
+      "export_sha256": "4302bda642387ec2025823999ef1fffc8cdf2aeaa053c9f9dc7085000406880f",
+      "original_sha256": "4302bda642387ec2025823999ef1fffc8cdf2aeaa053c9f9dc7085000406880f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/ema.py": {
+      "export_sha256": "e5491ff90a50f8170c0cc0cd5856a21fe1d084544de691652b5295cb758c8f82",
+      "original_sha256": "e5491ff90a50f8170c0cc0cd5856a21fe1d084544de691652b5295cb758c8f82"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/full_finetune_runtime.py": {
+      "export_sha256": "8916dda6cfc814bdca6f330e3cf1e97c15b5050466c2844aa78a5dd358949919",
+      "original_sha256": "8916dda6cfc814bdca6f330e3cf1e97c15b5050466c2844aa78a5dd358949919"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/helper.py": {
+      "export_sha256": "c35007430238271bcf394cd7d870ae66ac0c92413babbddca64732db6ee7d356",
+      "original_sha256": "c35007430238271bcf394cd7d870ae66ac0c92413babbddca64732db6ee7d356"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/import_utils.py": {
+      "export_sha256": "1cfa2f06905d3fa0a32d08dc8973e32b6bcbf071a80f014d6371515b6b32a66f",
+      "original_sha256": "1cfa2f06905d3fa0a32d08dc8973e32b6bcbf071a80f014d6371515b6b32a66f"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/logging.py": {
+      "export_sha256": "0311934e4d0382950bf2f1c77435117f3f8ce673d1bfec62d46e8cd83d6b0610",
+      "original_sha256": "0311934e4d0382950bf2f1c77435117f3f8ce673d1bfec62d46e8cd83d6b0610"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/lora_utils.py": {
+      "export_sha256": "cc43360c66ec7062ee4302cd3bdd83771754b7cf2fc05af4694b8f820718b85d",
+      "original_sha256": "cc43360c66ec7062ee4302cd3bdd83771754b7cf2fc05af4694b8f820718b85d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/model_utils.py": {
+      "export_sha256": "fc4874db144ac2d21c5ead866c7b79151dbbf6e2d1b3998011f56bab23465d7c",
+      "original_sha256": "fc4874db144ac2d21c5ead866c7b79151dbbf6e2d1b3998011f56bab23465d7c"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/moe_utils.py": {
+      "export_sha256": "378054f52b2aac9c59459278dadfceb4acf78f4b21a6e7934cd518031ae2a66d",
+      "original_sha256": "378054f52b2aac9c59459278dadfceb4acf78f4b21a6e7934cd518031ae2a66d"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/normalize.py": {
+      "export_sha256": "64020713950bcb27b3589c12219292ed1859a090c986c69fdc5b62e053fd5737",
+      "original_sha256": "64020713950bcb27b3589c12219292ed1859a090c986c69fdc5b62e053fd5737"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/phase4_measurement.py": {
+      "export_sha256": "cd2ce7e2eae105cc01a665bd7863945c319c86cce7e586d2d522ed99a1d3d9bd",
+      "original_sha256": "cd2ce7e2eae105cc01a665bd7863945c319c86cce7e586d2d522ed99a1d3d9bd"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/process.py": {
+      "export_sha256": "a50241f6408cb09fa6c6d633c21e32504826a16b275fe995f39d46a0f78fe1f3",
+      "original_sha256": "a50241f6408cb09fa6c6d633c21e32504826a16b275fe995f39d46a0f78fe1f3"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/recompute_utils.py": {
+      "export_sha256": "efee9e750d0788f699e9de82da0a06caa7f961d26e748075457be2bc35430158",
+      "original_sha256": "efee9e750d0788f699e9de82da0a06caa7f961d26e748075457be2bc35430158"
+    },
+    "third_party/lingbot-vla-v2/lingbotvla/utils/seqlen_pos_transform_utils.py": {
+      "export_sha256": "9db5f54ff91bcb8384ae8e88f8b430bfe018c2a7e07382f885cc2646894056d3",
+      "original_sha256": "9db5f54ff91bcb8384ae8e88f8b430bfe018c2a7e07382f885cc2646894056d3"
+    },
+    "third_party/lingbot-vla-v2/pyproject.toml": {
+      "export_sha256": "89af0b07014aa2a0d4c5eb387181cda56cd3d21a98d360abf691dea4dc200549",
+      "original_sha256": "89af0b07014aa2a0d4c5eb387181cda56cd3d21a98d360abf691dea4dc200549"
+    },
+    "third_party/lingbot-vla-v2/requirements-depth.txt": {
+      "export_sha256": "95333d7165ab18c2d31c62a0d07c93e8b20f024fa0c8488fe7f386038592400d",
+      "original_sha256": "95333d7165ab18c2d31c62a0d07c93e8b20f024fa0c8488fe7f386038592400d"
+    },
+    "third_party/lingbot-vla-v2/requirements.txt": {
+      "export_sha256": "4bea8eca2e5e81107332947fe38d9a2787bc6a8fe4d3f875fa7e3d028f48993d",
+      "original_sha256": "4bea8eca2e5e81107332947fe38d9a2787bc6a8fe4d3f875fa7e3d028f48993d"
+    },
+    "third_party/lingbot-vla-v2/setup.py": {
+      "export_sha256": "11fdc0d257f4fe68cabf161355843632628807549db6df751a38f0ca2f949ba5",
+      "original_sha256": "11fdc0d257f4fe68cabf161355843632628807549db6df751a38f0ca2f949ba5"
+    },
+    "third_party/lingbot-vla-v2/tasks/vla/train_lingbotvla.py": {
+      "export_sha256": "7f12af769d8c75dc5fcc19b1de63cba02672ba5caf187609aaa2199183746352",
+      "original_sha256": "7f12af769d8c75dc5fcc19b1de63cba02672ba5caf187609aaa2199183746352"
+    },
+    "third_party/lingbot-vla-v2/tasks/vla/train_pi0.py": {
+      "export_sha256": "437b3fb2b802beccd208b60086be1bbb2a00f396e11796d18803f913ec63f0f2",
+      "original_sha256": "437b3fb2b802beccd208b60086be1bbb2a00f396e11796d18803f913ec63f0f2"
+    },
+    "third_party/lingbot-vla-v2/train.sh": {
+      "export_sha256": "a84bcd8043446435f02dbbeab0b1b2d3dca4cadb86e484b2a048c019edc72cef",
+      "original_sha256": "a84bcd8043446435f02dbbeab0b1b2d3dca4cadb86e484b2a048c019edc72cef"
+    },
+    "training_reference/scripts/e5_rollout_history.py": {
+      "export_sha256": "284fde2bb25421671132b0dbceedee9d14963117638eb7fc1693e5cacc8f0e7a",
+      "original_sha256": "284fde2bb25421671132b0dbceedee9d14963117638eb7fc1693e5cacc8f0e7a"
+    }
+  },
+  "portable_changes": [
+    {
+      "change": "Load the public sanitized training_config.yaml beside checkpoint shards instead of requiring the original training output directory topology. Numerical inference code unchanged.",
+      "file": "third_party/lingbot-vla-v2/deploy/lingbot_vla_v2_policy.py"
+    },
+    {
+      "change": "dataset root made relative to upstream training working directory",
+      "file": "manifests/e5_allclean_train.txt",
+      "new_value": "../../data/lerobot/",
+      "old_value_omitted": true
+    },
+    {
+      "field": "train.output_dir",
+      "file": "configs/ep2_training.yaml",
+      "new_value": "outputs/train",
+      "old_value_omitted": true
+    },
+    {
+      "field": "train.output_dir",
+      "file": "configs/ep6_training.yaml",
+      "new_value": "outputs/train",
+      "old_value_omitted": true
+    },
+    {
+      "change": "Use exact source from both actual evaluations; retain earlier training-archive version under training_reference/scripts/e5_rollout_history.py.",
+      "file": "scripts/e5_rollout_history.py"
+    },
+    {
+      "change": "Replace machine/run-record identity checks with portable public checkpoint hash checks; support epoch2 and epoch6 via E5_EPOCH. Loading and rollout computation unchanged.",
+      "file": "scripts/eval_model_registry.py",
+      "old_value_omitted": true
+    },
+    {
+      "change": "New portable planner/execution entry for the original server and per-episode worker; default plans only.",
+      "file": "scripts/release_eval.py"
+    }
+  ],
+  "source_archives": {
+    "ep2": "830d1e28a0dbff4d8d7a127ac236fe8e6da88e3b1096e581914ad5288967e10c",
+    "ep6": "77c95a4d09b5dc44358b46c3598203f09d1f1de26540e2883c15039212816c0a"
+  }
+}

TRAINING.md

@@ -0,0 +1,62 @@
+# Training method and reproduction
+
+E5 adds public state history as two tokens (stride 50) and an executed-action summary
+of the last eight commands; visual history is disabled. Action/state history masks remain
+independent. Public state history means prior drive-target observations at policy decisions,
+not measured qpos. See `scripts/e5_rollout_history.py` and the history implementations under
+`third_party/lingbot-vla-v2/lingbotvla/`.
+
+C3 augmentation is enabled at probability 0.8; camera keys receive independent draws,
+while temporal frames share parameters, maps and noise per camera. Photometric perturbations
+and probability-0.5 Fourier amplitude jitter are enabled; background/style are disabled.
+Current and future depth/video teacher pixels share the augmented images, with no cached teacher
+features. The exact parameters are in `configs/augmentation/c3_v1.json` and actual configs.
+
+Both runs use 2500 clean trajectories, 549787 frames, no holdout or validation selection,
+fresh official baseline initialization, seed 7, Muon, mixed BF16 computation and FP32 master
+and exported checkpoint parameters. Configs retain the actual LR schedule, FSDP2, action/state
+sizes, teacher loss weights, history settings, normalization and dependency layout.
+
+| Run | Epochs | Steps | GPUs | Microbatch | Accumulation | Global batch | LR | Minimum LR |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| ep2 | 2 | 17180 | 4 | 8 | 2 | 64 | 0.0001 | 5e-05 |
+| ep6 | 6 | 17178 | 8 | 12 | 2 | 192 | 0.00015 | 7.5e-05 |
+
+Install the original runtime requirements from `third_party/lingbot-vla-v2/` into a compatible
+CUDA environment. Place the official base in `checkpoints/base/lingbot-vla-v2-6b`, Qwen3-VL
+and MoGe dependencies in the paths specified by the configs, and the original RoboTwin LeRobot
+trajectory directories under `data/lerobot`. Training manifests include both original train/val
+directories intentionally: the actual all-clean runs have no held-out validation split.
+These assets are dependencies and are not included in this Git repository.
+
+Run from `third_party/lingbot-vla-v2` so `../../` config references resolve to repository root.
+Set `MASTER_ADDR`, `MASTER_PORT`, `NODE_RANK` and `PHASE4_NODE_LOCAL_ROOT` from the allocated
+training environment. For epoch2 use NNODES=1, NPROC_PER_NODE=4 and NODE_RANK=0; epoch6 uses
+NNODES=2 and NPROC_PER_NODE=4 on each node. `TRAIN_CONFIG` is `../../configs/ep2_training.yaml`
+or `../../configs/ep6_training.yaml`; `RANK_ENTRY` is `../../deployment/finetune/e5_rank_entry.py`
+or `../../deployment/finetune/e5_8gpu_rank_entry.py` respectively.
+
+```bash
+export PHASE4_HF_EXPORT_DTYPE=fp32
+export PHASE4_STATE_HISTORY_REQUIRED=1
+export PHASE4_ACTION_HISTORY_REQUIRED=1
+export PHASE4_VALIDATION_CACHE=0
+export PHASE4_HF_DEDUP=0
+export PHASE4_PERF_MODE=0
+export PHASE4_DEPTH_TEACHER_BATCH=0
+python -m torch.distributed.run --nnodes="$NNODES" --nproc-per-node="$NPROC_PER_NODE"   --node-rank="$NODE_RANK" --master-addr="$MASTER_ADDR" --master-port="$MASTER_PORT"   --max-restarts=0 "$RANK_ENTRY" tasks/vla/train_lingbotvla.py "$TRAIN_CONFIG"
+```
+
+This portable invocation exposes the original training entry and recipe. It has not been
+rerun for this release and does not recreate the original scheduler, data staging or recovery
+orchestration. The actual run completion records report zero automatic restarts. Use the
+actual sanitized configs, not similarly named generic upstream examples.
+
+Final training losses and elapsed training seconds are reported in `RESULTS.json`.
+![Actual original optimizer-step training losses](loss/original_training.svg)
+
+The plots show each actual optimizer-step loss and a labeled trailing 100-step mean (shorter
+prefix window at the beginning). The rank0 metric records contain total loss all-reduced
+over the FSDP group. Scalar-only CSVs are in `loss/ep2.csv` and `loss/ep6.csv`; coverage and
+original record SHA256 values are in `loss/summary.json`. Both series cover every optimizer
+step without gaps. Raw logs and all non-scalar metadata remain local: 原始记录保存在本地。

configs/augmentation/c3_v1.json

@@ -0,0 +1,62 @@
+{
+  "schema_version": 1,
+  "enabled": true,
+  "p": 0.8,
+  "photometric": {
+    "brightness": [
+      0.9,
+      1.1
+    ],
+    "contrast": [
+      0.9,
+      1.1
+    ],
+    "saturation": [
+      0.95,
+      1.05
+    ],
+    "gamma": [
+      0.9,
+      1.1
+    ],
+    "exposure_ev": [
+      -0.1,
+      0.1
+    ],
+    "color_temperature": 0.025,
+    "gaussian_noise_std": [
+      0.0,
+      0.005
+    ],
+    "blur_p": 0.15,
+    "blur_sigma": [
+      0.1,
+      0.5
+    ],
+    "hue": 0.0
+  },
+  "fourier": {
+    "enabled": true,
+    "p": 0.5,
+    "amp_jitter": [
+      0.9,
+      1.1
+    ],
+    "envelope_strength": [
+      0.0,
+      0.1
+    ],
+    "envelope_grid": 8,
+    "preserve_dc": true,
+    "conjugate_symmetric": true
+  },
+  "style": {
+    "enabled": false
+  },
+  "background": {
+    "enabled": false
+  },
+  "camera_rule": "independent_by_camera_key",
+  "temporal_rule": "same_parameters_map_and_noise_per_camera",
+  "teacher_rule": "same_augmented_current_and_future_pixels_no_feature_cache"
+}

configs/ep2_training.yaml

@@ -0,0 +1,280 @@
+data:
+  c3_allow_state_action_history: true
+  c3_augmentation_config: '{"background":{"enabled":false},"camera_rule":"independent_by_camera_key","enabled":true,"fourier":{"amp_jitter":[0.9,1.1],"conjugate_symmetric":true,"enabled":true,"envelope_grid":8,"envelope_strength":[0.0,0.1],"p":0.5,"preserve_dc":true},"p":0.8,"photometric":{"blur_p":0.15,"blur_sigma":[0.1,0.5],"brightness":[0.9,1.1],"color_temperature":0.025,"contrast":[0.9,1.1],"exposure_ev":[-0.1,0.1],"gamma":[0.9,1.1],"gaussian_noise_std":[0.0,0.005],"hue":0.0,"saturation":[0.95,1.05]},"schema_version":1,"style":{"enabled":false},"teacher_rule":"same_augmented_current_and_future_pixels_no_feature_cache","temporal_rule":"same_parameters_map_and_noise_per_camera"}'
+  cameras:
+  - camera_top
+  - camera_wrist_left
+  - camera_wrist_right
+  chat_template: default
+  data_name: multi
+  data_root: null
+  data_tag: default
+  data_type: conversation
+  dataloader_type: native
+  datasets_type: vla
+  drop_last: true
+  image_augment: false
+  image_keys: images
+  img_size: 256
+  joints:
+  - '{''arm.position'': 14}'
+  - '{''end.position'': 14}'
+  - '{''effector.position'': 2}'
+  max_seq_len: 2048
+  norm_stats_file: ../../manifests/norm_stats/robotwin_clean_train_s7.json
+  norm_type:
+  - '{''arm.position'': ''bounds_99_woclip''}'
+  - '{''end.position'': ''bounds_99_woclip''}'
+  - '{''effector.position'': ''bounds_99_woclip''}'
+  num_workers: 4
+  pin_memory: true
+  prefetch_factor: 4
+  prompt_type: global
+  robot_config_root: ../../configs/phase4_robot_configs
+  source_name: null
+  state_norm_type: none
+  text_keys: messages
+  train_path: ../../manifests/e5_allclean_train.txt
+  train_size: 10000000
+  use_future_image: true
+model:
+  adanorm_time: true
+  attn_implementation: flash_attention_2
+  basic_modules: []
+  config_key: LingbotVLAV2Config
+  config_path: ../../checkpoints/base/lingbot-vla-v2-6b
+  decoders: {}
+  encode_target: false
+  encoders: {}
+  final_norm_adanorm: false
+  force_use_huggingface: false
+  incremental_training: false
+  input_encoder: encoder
+  model_path: ../../checkpoints/base/lingbot-vla-v2-6b
+  moe_implementation: fused
+  output_encoder: decoder
+  post_training: true
+  tokenizer_path: ../../checkpoints/dependencies/Qwen3-VL-4B-Instruct
+  use_lm_head: false
+  vit_attn_implementation: flash_attention_2
+  vlm_repo_id: null
+  vocab_size: 0
+train:
+  action_dim: 55
+  action_fp32: false
+  action_history_length: 8
+  action_history_mlp_hidden_size: 1024
+  action_history_mode: summary
+  activation_gpu_limit: 0.0
+  align_params:
+    depth:
+      block_future_depth_to_action: false
+      detach_future_image_feats: true
+      dim_head: 32
+      dim_out: 1024
+      ff_mult: 1
+      input_size: 224
+      model_type: MoRGBD
+      moge_path: ../../checkpoints/dependencies/moge-2-vitb-normal/model.pt
+      morgbd_path: ../../checkpoints/base/lingbot-vla-v2-6b/depth/model.pt
+      num_backbone_tokens: 256
+      num_heads: 4
+      num_layers: 1
+      token_size: 16
+      use_future_depth: true
+    depth_loss_weight: 0.004
+    future_depth_loss_weight: 0.004
+    llm:
+      dim_out: 2560
+      image_input_size: 224
+      image_token_size: 8
+    mode: query
+    num_task_tokens: 8
+    use_future_video: true
+    video:
+      attention_mode: flex_block_causal
+      block_suffix_to_future_video: false
+      ckpt_path: ../../checkpoints/base/lingbot-vla-v2-6b/dino_video/teacher_step_10000.pth
+      cls_loss_type: mse
+      cls_loss_weight: 0.2
+      cls_pool: last
+      config_path: ../../checkpoints/base/lingbot-vla-v2-6b/dino_video/config.yaml
+      cosine_loss_weight: 0.2
+      detach_image_feats: true
+      dim_head: 32
+      dim_out: 1024
+      effective_fps: 1.0
+      ff_mult: 1
+      future_video_loss_weight: 0.004
+      input_size: 256
+      log_max_samples: 32
+      log_scale: 16
+      mse_loss_weight: 1.0
+      n_blocks: 1
+      num_backbone_tokens: 256
+      num_future_frames: 1
+      num_heads: 4
+      num_layers: 1
+      share_future_depth_query: true
+      use_cls_loss: false
+      use_cosine_loss: true
+      use_current_patch_loss: true
+      use_current_shared_task_proj: true
+      use_mse_loss: true
+      use_patch_loss: true
+      use_shared_future_task_proj: true
+      use_smooth_l1_loss: false
+      use_warmup_frame: true
+    visual_steps: 5000
+  allow_partial_checkpoint: false
+  async_hf_max_pending: 1
+  async_save_hf_weights: false
+  attention_implementation: flex_cached
+  bias_centering: false
+  bias_update_interval: 1
+  bias_update_speed: 0.0
+  bsz_warmup_init_mbtoken: 200
+  bsz_warmup_ratio: 0
+  chunk_size: 50
+  ckpt_manager: dcp
+  context_parallel_size: 1
+  data_parallel_mode: fsdp2
+  data_parallel_replicate_size: 1
+  data_parallel_shard_size: 4
+  decayed_max_grad_norm: 1.0
+  dyn_bsz: true
+  dyn_bsz_buffer_size: 200
+  dyn_bsz_margin: 0
+  empty_cache_steps: 500
+  enable_activation_offload: false
+  enable_forward_prefetch: true
+  enable_fp32: false
+  enable_fsdp_offload: false
+  enable_full_determinism: false
+  enable_full_shard: true
+  enable_gradient_checkpointing: true
+  enable_manual_eager: false
+  enable_mixed_precision: true
+  enable_profiling: false
+  enable_reentrant: false
+  enable_resume: false
+  expert_hidden_size: 768
+  expert_intermediate_size: 2752
+  expert_parallel_size: 1
+  freeze_vision_encoder: false
+  freeze_vit: false
+  global_batch_size: 64
+  gradient_accumulation_steps: 2
+  init_device: cuda
+  load_checkpoint_path: null
+  loss_type: L1_fm
+  lr: 0.0001
+  lr_decay_ratio: 1.0
+  lr_decay_style: cosine
+  lr_min: 5.0e-05
+  lr_start: 0.0
+  lr_warmup_ratio: 0.0
+  max_action_dim: 55
+  max_grad_norm: 1.0
+  max_state_dim: 55
+  max_steps: 17180
+  micro_batch_size: 8
+  module_fsdp_enable: true
+  moe_monitor_interval: 1000
+  muon_adjust_lr_fn: match_rms_adamw
+  muon_exclude_name_patterns: []
+  muon_momentum: 0.95
+  muon_nesterov: true
+  muon_ns_steps: 5
+  my_tokenizer_max_length: 72
+  num_train_epochs: 2
+  optimizer: muon
+  output_dir: outputs/train
+  pipeline_parallel_size: 1
+  precompute_grid_thw: true
+  profile_end_step: 2
+  profile_profile_memory: true
+  profile_record_shapes: true
+  profile_start_step: 1
+  profile_trace_dir: ./trace
+  profile_with_stack: true
+  resume_dataloader_state: true
+  rmpad: false
+  rmpad_with_pos_ids: false
+  routed_scaling_factor: 4.0
+  router_activation: sigmoid
+  router_z_loss_coeff: 0.0001
+  save_epochs: 0
+  save_hf_weights: true
+  save_steps: 1000
+  seed: 7
+  sequence_wise_loss_coeff: 0.001
+  sequence_wise_mode: per_sequence
+  split_fused_experts_from_decoder_fsdp: false
+  stable_train_steps: 100000
+  state_history_length: 2
+  state_history_mode: tokens
+  state_history_stride: 50
+  tensor_parallel_size: 1
+  token_moe_intermediate_size: 512
+  token_moe_layers:
+  - 0
+  - 1
+  - 2
+  - 3
+  - 4
+  - 5
+  - 6
+  - 7
+  - 8
+  - 9
+  - 10
+  - 11
+  - 12
+  - 13
+  - 14
+  - 15
+  - 16
+  - 17
+  - 18
+  - 19
+  - 20
+  - 21
+  - 22
+  - 23
+  - 24
+  - 25
+  - 26
+  - 27
+  - 28
+  - 29
+  - 30
+  - 31
+  - 32
+  - 33
+  - 34
+  - 35
+  token_num_experts: 32
+  token_shared_intermediate_size: 704
+  token_top_k: 4
+  tokenizer_max_length: 72
+  train_expert_only: false
+  train_state_proj: true
+  ulysses_parallel_size: 1
+  use_compile: true
+  use_doptim: false
+  use_moe: true
+  use_moe_expert_lr: true
+  use_shared_expert_gate: false
+  use_wandb: false
+  visual_history_gradient_checkpointing: true
+  visual_history_length: 2
+  visual_history_mode: none
+  visual_history_num_cameras: 3
+  visual_history_stride: 50
+  vit_lr: 1.0e-06
+  vlm_causal: true
+  vlm_fsdp: true
+  wandb_name: null
+  wandb_project: lingbotvla
+  weight_decay: 0.0

configs/ep6_training.yaml

@@ -0,0 +1,280 @@
+data:
+  c3_allow_state_action_history: true
+  c3_augmentation_config: '{"background":{"enabled":false},"camera_rule":"independent_by_camera_key","enabled":true,"fourier":{"amp_jitter":[0.9,1.1],"conjugate_symmetric":true,"enabled":true,"envelope_grid":8,"envelope_strength":[0.0,0.1],"p":0.5,"preserve_dc":true},"p":0.8,"photometric":{"blur_p":0.15,"blur_sigma":[0.1,0.5],"brightness":[0.9,1.1],"color_temperature":0.025,"contrast":[0.9,1.1],"exposure_ev":[-0.1,0.1],"gamma":[0.9,1.1],"gaussian_noise_std":[0.0,0.005],"hue":0.0,"saturation":[0.95,1.05]},"schema_version":1,"style":{"enabled":false},"teacher_rule":"same_augmented_current_and_future_pixels_no_feature_cache","temporal_rule":"same_parameters_map_and_noise_per_camera"}'
+  cameras:
+  - camera_top
+  - camera_wrist_left
+  - camera_wrist_right
+  chat_template: default
+  data_name: multi
+  data_root: null
+  data_tag: default
+  data_type: conversation
+  dataloader_type: native
+  datasets_type: vla
+  drop_last: true
+  image_augment: false
+  image_keys: images
+  img_size: 256
+  joints:
+  - '{''arm.position'': 14}'
+  - '{''end.position'': 14}'
+  - '{''effector.position'': 2}'
+  max_seq_len: 2048
+  norm_stats_file: ../../manifests/norm_stats/robotwin_clean_train_s7.json
+  norm_type:
+  - '{''arm.position'': ''bounds_99_woclip''}'
+  - '{''end.position'': ''bounds_99_woclip''}'
+  - '{''effector.position'': ''bounds_99_woclip''}'
+  num_workers: 4
+  pin_memory: true
+  prefetch_factor: 4
+  prompt_type: global
+  robot_config_root: ../../configs/phase4_robot_configs
+  source_name: null
+  state_norm_type: none
+  text_keys: messages
+  train_path: ../../manifests/e5_allclean_train.txt
+  train_size: 10000000
+  use_future_image: true
+model:
+  adanorm_time: true
+  attn_implementation: flash_attention_2
+  basic_modules: []
+  config_key: LingbotVLAV2Config
+  config_path: ../../checkpoints/base/lingbot-vla-v2-6b
+  decoders: {}
+  encode_target: false
+  encoders: {}
+  final_norm_adanorm: false
+  force_use_huggingface: false
+  incremental_training: false
+  input_encoder: encoder
+  model_path: ../../checkpoints/base/lingbot-vla-v2-6b
+  moe_implementation: fused
+  output_encoder: decoder
+  post_training: true
+  tokenizer_path: ../../checkpoints/dependencies/Qwen3-VL-4B-Instruct
+  use_lm_head: false
+  vit_attn_implementation: flash_attention_2
+  vlm_repo_id: null
+  vocab_size: 0
+train:
+  action_dim: 55
+  action_fp32: false
+  action_history_length: 8
+  action_history_mlp_hidden_size: 1024
+  action_history_mode: summary
+  activation_gpu_limit: 0.0
+  align_params:
+    depth:
+      block_future_depth_to_action: false
+      detach_future_image_feats: true
+      dim_head: 32
+      dim_out: 1024
+      ff_mult: 1
+      input_size: 224
+      model_type: MoRGBD
+      moge_path: ../../checkpoints/dependencies/moge-2-vitb-normal/model.pt
+      morgbd_path: ../../checkpoints/base/lingbot-vla-v2-6b/depth/model.pt
+      num_backbone_tokens: 256
+      num_heads: 4
+      num_layers: 1
+      token_size: 16
+      use_future_depth: true
+    depth_loss_weight: 0.004
+    future_depth_loss_weight: 0.004
+    llm:
+      dim_out: 2560
+      image_input_size: 224
+      image_token_size: 8
+    mode: query
+    num_task_tokens: 8
+    use_future_video: true
+    video:
+      attention_mode: flex_block_causal
+      block_suffix_to_future_video: false
+      ckpt_path: ../../checkpoints/base/lingbot-vla-v2-6b/dino_video/teacher_step_10000.pth
+      cls_loss_type: mse
+      cls_loss_weight: 0.2
+      cls_pool: last
+      config_path: ../../checkpoints/base/lingbot-vla-v2-6b/dino_video/config.yaml
+      cosine_loss_weight: 0.2
+      detach_image_feats: true
+      dim_head: 32
+      dim_out: 1024
+      effective_fps: 1.0
+      ff_mult: 1
+      future_video_loss_weight: 0.004
+      input_size: 256
+      log_max_samples: 32
+      log_scale: 16
+      mse_loss_weight: 1.0
+      n_blocks: 1
+      num_backbone_tokens: 256
+      num_future_frames: 1
+      num_heads: 4
+      num_layers: 1
+      share_future_depth_query: true
+      use_cls_loss: false
+      use_cosine_loss: true
+      use_current_patch_loss: true
+      use_current_shared_task_proj: true
+      use_mse_loss: true
+      use_patch_loss: true
+      use_shared_future_task_proj: true
+      use_smooth_l1_loss: false
+      use_warmup_frame: true
+    visual_steps: 5000
+  allow_partial_checkpoint: false
+  async_hf_max_pending: 1
+  async_save_hf_weights: false
+  attention_implementation: flex_cached
+  bias_centering: false
+  bias_update_interval: 1
+  bias_update_speed: 0.0
+  bsz_warmup_init_mbtoken: 200
+  bsz_warmup_ratio: 0
+  chunk_size: 50
+  ckpt_manager: dcp
+  context_parallel_size: 1
+  data_parallel_mode: fsdp2
+  data_parallel_replicate_size: 1
+  data_parallel_shard_size: 8
+  decayed_max_grad_norm: 1.0
+  dyn_bsz: true
+  dyn_bsz_buffer_size: 200
+  dyn_bsz_margin: 0
+  empty_cache_steps: 500
+  enable_activation_offload: false
+  enable_forward_prefetch: true
+  enable_fp32: false
+  enable_fsdp_offload: false
+  enable_full_determinism: false
+  enable_full_shard: true
+  enable_gradient_checkpointing: true
+  enable_manual_eager: false
+  enable_mixed_precision: true
+  enable_profiling: false
+  enable_reentrant: false
+  enable_resume: false
+  expert_hidden_size: 768
+  expert_intermediate_size: 2752
+  expert_parallel_size: 1
+  freeze_vision_encoder: false
+  freeze_vit: false
+  global_batch_size: 192
+  gradient_accumulation_steps: 2
+  init_device: cuda
+  load_checkpoint_path: null
+  loss_type: L1_fm
+  lr: 0.00015
+  lr_decay_ratio: 1.0
+  lr_decay_style: cosine
+  lr_min: 7.5e-05
+  lr_start: 0.0
+  lr_warmup_ratio: 0.0
+  max_action_dim: 55
+  max_grad_norm: 1.0
+  max_state_dim: 55
+  max_steps: 17178
+  micro_batch_size: 12
+  module_fsdp_enable: true
+  moe_monitor_interval: 1000
+  muon_adjust_lr_fn: match_rms_adamw
+  muon_exclude_name_patterns: []
+  muon_momentum: 0.95
+  muon_nesterov: true
+  muon_ns_steps: 5
+  my_tokenizer_max_length: 72
+  num_train_epochs: 6
+  optimizer: muon
+  output_dir: outputs/train
+  pipeline_parallel_size: 1
+  precompute_grid_thw: true
+  profile_end_step: 2
+  profile_profile_memory: true
+  profile_record_shapes: true
+  profile_start_step: 1
+  profile_trace_dir: ./trace
+  profile_with_stack: true
+  resume_dataloader_state: true
+  rmpad: false
+  rmpad_with_pos_ids: false
+  routed_scaling_factor: 4.0
+  router_activation: sigmoid
+  router_z_loss_coeff: 0.0001
+  save_epochs: 0
+  save_hf_weights: true
+  save_steps: 1000
+  seed: 7
+  sequence_wise_loss_coeff: 0.001
+  sequence_wise_mode: per_sequence
+  split_fused_experts_from_decoder_fsdp: false
+  stable_train_steps: 100000
+  state_history_length: 2
+  state_history_mode: tokens
+  state_history_stride: 50
+  tensor_parallel_size: 1
+  token_moe_intermediate_size: 512
+  token_moe_layers:
+  - 0
+  - 1
+  - 2
+  - 3
+  - 4
+  - 5
+  - 6
+  - 7
+  - 8
+  - 9
+  - 10
+  - 11
+  - 12
+  - 13
+  - 14
+  - 15
+  - 16
+  - 17
+  - 18
+  - 19
+  - 20
+  - 21
+  - 22
+  - 23
+  - 24
+  - 25
+  - 26
+  - 27
+  - 28
+  - 29
+  - 30
+  - 31
+  - 32
+  - 33
+  - 34
+  - 35
+  token_num_experts: 32
+  token_shared_intermediate_size: 704
+  token_top_k: 4
+  tokenizer_max_length: 72
+  train_expert_only: false
+  train_state_proj: true
+  ulysses_parallel_size: 1
+  use_compile: true
+  use_doptim: false
+  use_moe: true
+  use_moe_expert_lr: true
+  use_shared_expert_gate: false
+  use_wandb: false
+  visual_history_gradient_checkpointing: true
+  visual_history_length: 2
+  visual_history_mode: none
+  visual_history_num_cameras: 3
+  visual_history_stride: 50
+  vit_lr: 1.0e-06
+  vlm_causal: true
+  vlm_fsdp: true
+  wandb_name: null
+  wandb_project: lingbotvla
+  weight_decay: 0.0

configs/evaluation/ep2.json

@@ -0,0 +1,44 @@
+{
+  "epoch": 2,
+  "files": {
+    "config.json": {
+      "bytes": 4776,
+      "sha256": "cee2cacb112d867b02f762b9b0bf6800c86020654deae6944d947613315c7748"
+    },
+    "model-00001-of-00006.safetensors": {
+      "bytes": 4947507248,
+      "sha256": "019db3a1cf8c8daf429e5e13360675a6047499a23400f609600b9bb5d54477f3"
+    },
+    "model-00002-of-00006.safetensors": {
+      "bytes": 4944315304,
+      "sha256": "51bafb87d5df23ed6ca7f211435154beac93003d911c279675814be893d8f3ce"
+    },
+    "model-00003-of-00006.safetensors": {
+      "bytes": 4944315360,
+      "sha256": "97ecf74efc7cef237bcf513078b3940d714e26965b34deedea5274103f6d8fa3"
+    },
+    "model-00004-of-00006.safetensors": {
+      "bytes": 4992858968,
+      "sha256": "4eef0f6f39f9c091cc89b102a04e6d4b2ab7609717e21d3c93c3501fa6e6d58f"
+    },
+    "model-00005-of-00006.safetensors": {
+      "bytes": 4963062048,
+      "sha256": "9bff6d6e87cac8d662487a77517bb88d9d22d18a73c26d87fd98036a4e05e87c"
+    },
+    "model-00006-of-00006.safetensors": {
+      "bytes": 717000908,
+      "sha256": "2716881bbbcfb87b5ad26484c8ae459e5ebca57545f7f8bd52e6facdc0219dcd"
+    },
+    "model.safetensors.index.json": {
+      "bytes": 208079,
+      "sha256": "7177b91ebc4be824b667a27ff11e1c2786c919c9d5ec3df4026143250219c331"
+    },
+    "training_config.yaml": {
+      "bytes": 7533,
+      "sha256": "e268943fc0f87701a40f58fcd095e0452eae2d51f1b836c301e52ad0d318d92b"
+    }
+  },
+  "normalization_sha256": "51f709ad7b1c9f5b0d94711b96ed4eb56a711791b5720f8291ac1cb727990205",
+  "repo_id": "ar-mine/lingbot-vla-v2-6b-e5-c3-epoch2-step17180",
+  "step": 17180
+}

configs/evaluation/ep6.json

@@ -0,0 +1,44 @@
+{
+  "epoch": 6,
+  "files": {
+    "config.json": {
+      "bytes": 4776,
+      "sha256": "cee2cacb112d867b02f762b9b0bf6800c86020654deae6944d947613315c7748"
+    },
+    "model-00001-of-00006.safetensors": {
+      "bytes": 4947507248,
+      "sha256": "9e6d91452578e4f29c76d1265b4630350ed34f7b1585283a215cbafe8ed3a3d1"
+    },
+    "model-00002-of-00006.safetensors": {
+      "bytes": 4944315304,
+      "sha256": "3e5b2928cba366c983f11d66d535009addc18b6481b0acf8bc204acc5e938d42"
+    },
+    "model-00003-of-00006.safetensors": {
+      "bytes": 4944315360,
+      "sha256": "e8fbc25d6109049db6905244069cde7a420b476e5800dd40ea15290eedcb9604"
+    },
+    "model-00004-of-00006.safetensors": {
+      "bytes": 4992858968,
+      "sha256": "1b3d24a9981b7d1ebeb98f1c9417acfaa2ed0e81fa0968df0d5698e32b6acc4c"
+    },
+    "model-00005-of-00006.safetensors": {
+      "bytes": 4963062048,
+      "sha256": "5b79ccb6c236a6dcba4b77f36714b7b1fec8db9dfb76657ad71ce056b2f12780"
+    },
+    "model-00006-of-00006.safetensors": {
+      "bytes": 717000908,
+      "sha256": "b5dbcd73372a344e0f8c9eb5cba54d7f5d19d0df7dbaa9c78a37de5aebcc7d95"
+    },
+    "model.safetensors.index.json": {
+      "bytes": 208079,
+      "sha256": "7177b91ebc4be824b667a27ff11e1c2786c919c9d5ec3df4026143250219c331"
+    },
+    "training_config.yaml": {
+      "bytes": 7536,
+      "sha256": "f39cd9bbadfaea705e0b6647e9a869cdc40140907dba8bd369db1edd8ee17701"
+    }
+  },
+  "normalization_sha256": "51f709ad7b1c9f5b0d94711b96ed4eb56a711791b5720f8291ac1cb727990205",
+  "repo_id": "ar-mine/lingbot-vla-v2-6b-e5-c3-epoch6-step17178",
+  "step": 17178
+}

configs/evaluation/subset_binding.json

@@ -0,0 +1,20 @@
+{
+  "files": {
+    "benchmarks/robotwin_eval_subset_v2_seen_unseen/SHA256SUMS": {
+      "bytes": 55099,
+      "sha256": "a8a41f7c5162732cce287e77628840bf754f631825d3a6a343d51c648f932eb9"
+    },
+    "benchmarks/robotwin_eval_subset_v2_seen_unseen/protocol.json": {
+      "bytes": 4520,
+      "sha256": "30a5a691f001c3845b5ca41ca3f4ea111610b52efb82509311c24e4066f96efb"
+    },
+    "release.json": {
+      "bytes": 2499,
+      "sha256": "3cf0b0bf6c81562407b6e660557f128d2eee620b92f8917fb5ae5a17bb470eb1"
+    }
+  },
+  "hf_revision": "73277c2022be224d3afb195b503a3cff56ded46d",
+  "original_checksum_file_byte_identical": true,
+  "original_github_data_commit": "b5abe512dafd400736c6dca5905f2fd262dd9029",
+  "repo_id": "ar-mine/robotwin-eval-subset-v2-seen-unseen"
+}

configs/phase4_robot_configs/robotwin.yaml

@@ -0,0 +1,46 @@
+# Same joint/camera mapping as the pinned official robotwin.yaml.
+# Relative paths are resolved from third_party/lingbot-vla-v2 (training cwd).
+states:
+  - observation.state.arm.position:
+      origin_keys:
+        - observation.state:
+            start: 0
+            end: 6
+        - observation.state:
+            start: 7
+            end: 13
+  - observation.state.effector.position:
+      origin_keys:
+        - observation.state:
+            start: 6
+            end: 7
+        - observation.state:
+            start: 13
+            end: 14
+actions:
+  - action.arm.position:
+      origin_keys:
+        - action:
+            start: 0
+            end: 6
+        - action:
+            start: 7
+            end: 13
+      subtract_state: false
+  - action.effector.position:
+      origin_keys:
+        - action:
+            start: 6
+            end: 7
+        - action:
+            start: 13
+            end: 14
+      subtract_state: false
+images:
+  - observation.images.camera_top:
+      origin_keys: observation.images.cam_high
+  - observation.images.camera_wrist_left:
+      origin_keys: observation.images.cam_left_wrist
+  - observation.images.camera_wrist_right:
+      origin_keys: observation.images.cam_right_wrist
+norm_stats: ../../manifests/norm_stats/robotwin_clean_train_s7.json

deployment/finetune/e5_8gpu_rank_entry.py

@@ -0,0 +1,33 @@
+"""Give each training rank its own node-local compiler caches before imports."""
+import json
+import os
+from pathlib import Path
+import sys
+
+
+def configure_rank_cache(environment):
+    base = Path(environment['PHASE4_NODE_LOCAL_ROOT'])
+    rank = int(environment['RANK'])
+    if not 0 <= rank < 8:
+        raise ValueError('Expected one of eight training ranks')
+    cache = base / 'rank_cache' / ('rank_%d' % rank)
+    variables = {
+        'TORCHINDUCTOR_CACHE_DIR': 'inductor',
+        'TRITON_CACHE_DIR': 'triton',
+        'TORCH_EXTENSIONS_DIR': 'extensions',
+        'CUDA_CACHE_PATH': 'cuda',
+        'TORCH_HOME': 'torch',
+        'XDG_CACHE_HOME': 'xdg',
+    }
+    for variable, name in variables.items():
+        path = cache / name
+        path.mkdir(parents=True, exist_ok=True)
+        environment[variable] = str(path)
+    receipt = dict(rank=rank, paths={k: environment[k] for k in variables})
+    (cache / 'environment.json').write_text(json.dumps(receipt, indent=2) + '\n')
+    return receipt
+
+
+if __name__ == '__main__':
+    configure_rank_cache(os.environ)
+    os.execv(sys.executable, [sys.executable] + sys.argv[1:])

deployment/finetune/e5_rank_entry.py

@@ -0,0 +1,33 @@
+"""Give each training rank its own node-local compiler caches before imports."""
+import json
+import os
+from pathlib import Path
+import sys
+
+
+def configure_rank_cache(environment):
+    base = Path(environment['PHASE4_NODE_LOCAL_ROOT'])
+    rank = int(environment['RANK'])
+    if not 0 <= rank < 4:
+        raise ValueError('Expected one of four training ranks')
+    cache = base / 'rank_cache' / ('rank_%d' % rank)
+    variables = {
+        'TORCHINDUCTOR_CACHE_DIR': 'inductor',
+        'TRITON_CACHE_DIR': 'triton',
+        'TORCH_EXTENSIONS_DIR': 'extensions',
+        'CUDA_CACHE_PATH': 'cuda',
+        'TORCH_HOME': 'torch',
+        'XDG_CACHE_HOME': 'xdg',
+    }
+    for variable, name in variables.items():
+        path = cache / name
+        path.mkdir(parents=True, exist_ok=True)
+        environment[variable] = str(path)
+    receipt = dict(rank=rank, paths={k: environment[k] for k in variables})
+    (cache / 'environment.json').write_text(json.dumps(receipt, indent=2) + '\n')
+    return receipt
+
+
+if __name__ == '__main__':
+    configure_rank_cache(os.environ)
+    os.execv(sys.executable, [sys.executable] + sys.argv[1:])

loss/summary.json

@@ -0,0 +1,20 @@
+{
+  "ep2": {
+    "first_loss": 0.392822265625,
+    "last_100_mean_loss": 0.022859344482421873,
+    "last_loss": 0.019561767578125,
+    "optimizer_steps": 17180,
+    "plot_smoothing": "trailing 100 optimizer steps; shorter prefix window at start",
+    "raw_record_sha256": "0541f0f7e561b17fc17e535b73b1c6bec752519ce1dc94d8fa6bf903694c20a1",
+    "series_semantics": "rank0 phase4_optimizer_step loss, total loss all-reduced over FSDP group"
+  },
+  "ep6": {
+    "first_loss": 0.3944091796875,
+    "last_100_mean_loss": 0.016754798889160157,
+    "last_loss": 0.018779754638671875,
+    "optimizer_steps": 17178,
+    "plot_smoothing": "trailing 100 optimizer steps; shorter prefix window at start",
+    "raw_record_sha256": "1a12338e544b5acf0def73fb4a852219ae81c96831ee0df0a7fbc7e09874f4dd",
+    "series_semantics": "rank0 phase4_optimizer_step loss, total loss all-reduced over FSDP group"
+  }
+}

manifests/e5_allclean_train.txt

@@ -0,0 +1,100 @@
+robotwin ../../data/lerobot/adjust_bottle/train
+robotwin ../../data/lerobot/adjust_bottle/val
+robotwin ../../data/lerobot/beat_block_hammer/train
+robotwin ../../data/lerobot/beat_block_hammer/val
+robotwin ../../data/lerobot/blocks_ranking_rgb/train
+robotwin ../../data/lerobot/blocks_ranking_rgb/val
+robotwin ../../data/lerobot/blocks_ranking_size/train
+robotwin ../../data/lerobot/blocks_ranking_size/val
+robotwin ../../data/lerobot/click_alarmclock/train
+robotwin ../../data/lerobot/click_alarmclock/val
+robotwin ../../data/lerobot/click_bell/train
+robotwin ../../data/lerobot/click_bell/val
+robotwin ../../data/lerobot/dump_bin_bigbin/train
+robotwin ../../data/lerobot/dump_bin_bigbin/val
+robotwin ../../data/lerobot/grab_roller/train
+robotwin ../../data/lerobot/grab_roller/val
+robotwin ../../data/lerobot/handover_block/train
+robotwin ../../data/lerobot/handover_block/val
+robotwin ../../data/lerobot/handover_mic/train
+robotwin ../../data/lerobot/handover_mic/val
+robotwin ../../data/lerobot/hanging_mug/train
+robotwin ../../data/lerobot/hanging_mug/val
+robotwin ../../data/lerobot/lift_pot/train
+robotwin ../../data/lerobot/lift_pot/val
+robotwin ../../data/lerobot/move_can_pot/train
+robotwin ../../data/lerobot/move_can_pot/val
+robotwin ../../data/lerobot/move_pillbottle_pad/train
+robotwin ../../data/lerobot/move_pillbottle_pad/val
+robotwin ../../data/lerobot/move_playingcard_away/train
+robotwin ../../data/lerobot/move_playingcard_away/val
+robotwin ../../data/lerobot/move_stapler_pad/train
+robotwin ../../data/lerobot/move_stapler_pad/val
+robotwin ../../data/lerobot/open_laptop/train
+robotwin ../../data/lerobot/open_laptop/val
+robotwin ../../data/lerobot/open_microwave/train
+robotwin ../../data/lerobot/open_microwave/val
+robotwin ../../data/lerobot/pick_diverse_bottles/train
+robotwin ../../data/lerobot/pick_diverse_bottles/val
+robotwin ../../data/lerobot/pick_dual_bottles/train
+robotwin ../../data/lerobot/pick_dual_bottles/val
+robotwin ../../data/lerobot/place_a2b_left/train
+robotwin ../../data/lerobot/place_a2b_left/val
+robotwin ../../data/lerobot/place_a2b_right/train
+robotwin ../../data/lerobot/place_a2b_right/val
+robotwin ../../data/lerobot/place_bread_basket/train
+robotwin ../../data/lerobot/place_bread_basket/val
+robotwin ../../data/lerobot/place_bread_skillet/train
+robotwin ../../data/lerobot/place_bread_skillet/val
+robotwin ../../data/lerobot/place_burger_fries/train
+robotwin ../../data/lerobot/place_burger_fries/val
+robotwin ../../data/lerobot/place_can_basket/train
+robotwin ../../data/lerobot/place_can_basket/val
+robotwin ../../data/lerobot/place_cans_plasticbox/train
+robotwin ../../data/lerobot/place_cans_plasticbox/val
+robotwin ../../data/lerobot/place_container_plate/train
+robotwin ../../data/lerobot/place_container_plate/val
+robotwin ../../data/lerobot/place_dual_shoes/train
+robotwin ../../data/lerobot/place_dual_shoes/val
+robotwin ../../data/lerobot/place_empty_cup/train
+robotwin ../../data/lerobot/place_empty_cup/val
+robotwin ../../data/lerobot/place_fan/train
+robotwin ../../data/lerobot/place_fan/val
+robotwin ../../data/lerobot/place_mouse_pad/train
+robotwin ../../data/lerobot/place_mouse_pad/val
+robotwin ../../data/lerobot/place_object_basket/train
+robotwin ../../data/lerobot/place_object_basket/val
+robotwin ../../data/lerobot/place_object_scale/train
+robotwin ../../data/lerobot/place_object_scale/val
+robotwin ../../data/lerobot/place_object_stand/train
+robotwin ../../data/lerobot/place_object_stand/val
+robotwin ../../data/lerobot/place_phone_stand/train
+robotwin ../../data/lerobot/place_phone_stand/val
+robotwin ../../data/lerobot/place_shoe/train
+robotwin ../../data/lerobot/place_shoe/val
+robotwin ../../data/lerobot/press_stapler/train
+robotwin ../../data/lerobot/press_stapler/val
+robotwin ../../data/lerobot/put_bottles_dustbin/train
+robotwin ../../data/lerobot/put_bottles_dustbin/val
+robotwin ../../data/lerobot/put_object_cabinet/train
+robotwin ../../data/lerobot/put_object_cabinet/val
+robotwin ../../data/lerobot/rotate_qrcode/train
+robotwin ../../data/lerobot/rotate_qrcode/val
+robotwin ../../data/lerobot/scan_object/train
+robotwin ../../data/lerobot/scan_object/val
+robotwin ../../data/lerobot/shake_bottle/train
+robotwin ../../data/lerobot/shake_bottle/val
+robotwin ../../data/lerobot/shake_bottle_horizontally/train
+robotwin ../../data/lerobot/shake_bottle_horizontally/val
+robotwin ../../data/lerobot/stack_blocks_three/train
+robotwin ../../data/lerobot/stack_blocks_three/val
+robotwin ../../data/lerobot/stack_blocks_two/train
+robotwin ../../data/lerobot/stack_blocks_two/val
+robotwin ../../data/lerobot/stack_bowls_three/train
+robotwin ../../data/lerobot/stack_bowls_three/val
+robotwin ../../data/lerobot/stack_bowls_two/train
+robotwin ../../data/lerobot/stack_bowls_two/val
+robotwin ../../data/lerobot/stamp_seal/train
+robotwin ../../data/lerobot/stamp_seal/val
+robotwin ../../data/lerobot/turn_switch/train
+robotwin ../../data/lerobot/turn_switch/val

manifests/norm_stats/robotwin_clean_train_s7.json

@@ -0,0 +1,301 @@
+{
+  "norm_stats": {
+    "observation.state.arm.position": {
+      "mean": [
+        -0.2218015342950821,
+        1.0852952003479004,
+        0.7928197383880615,
+        -0.3323887884616852,
+        0.06101858988404274,
+        -0.0450562946498394,
+        0.23319873213768005,
+        1.1116381883621216,
+        0.8262677192687988,
+        -0.3407284915447235,
+        -0.015824314206838608,
+        0.009350035339593887
+      ],
+      "std": [
+        0.37363430857658386,
+        0.9939348697662354,
+        0.7864470481872559,
+        0.6720119714736938,
+        0.2499745935201645,
+        0.5507621765136719,
+        0.3234720826148987,
+        1.0183826684951782,
+        0.8076410889625549,
+        0.7207559943199158,
+        0.2623799443244934,
+        0.6163324117660522
+      ],
+      "q01": [
+        -0.9650917053222656,
+        -0.0003164021181873977,
+        -0.0017427727580070496,
+        -1.593807578086853,
+        -0.4257628321647644,
+        -2.1449642181396484,
+        -0.15960359573364258,
+        -0.0017502307891845703,
+        -0.0009148390963673592,
+        -1.7007898092269897,
+        -1.0327709913253784,
+        -1.6702170372009277
+      ],
+      "q99": [
+        0.1704568862915039,
+        2.5753180980682373,
+        2.469022035598755,
+        1.3214776515960693,
+        1.217225432395935,
+        1.4091839790344238,
+        1.0671677589416504,
+        2.6006040573120117,
+        2.49291729927063,
+        1.3017959594726562,
+        1.0509021282196045,
+        2.082728385925293
+      ],
+      "q02": [
+        -0.9208159446716309,
+        -0.0003164021181873977,
+        -0.0017427727580070496,
+        -1.509069561958313,
+        -0.3211984634399414,
+        -1.6351041793823242,
+        -0.07792139053344727,
+        -0.0017502307891845703,
+        -0.0009148390963673592,
+        -1.6116900444030762,
+        -0.9051415920257568,
+        -1.545118808746338
+      ],
+      "q98": [
+        0.14962148666381836,
+        2.49210786819458,
+        2.313790798187256,
+        1.1557180881500244,
+        1.0115631818771362,
+        1.1627516746520996,
+        0.9438738822937012,
+        2.52731990814209,
+        2.3536789417266846,
+        1.1985032558441162,
+        0.6835269927978516,
+        1.7406625747680664
+      ],
+      "min": [
+        -7.340834140777588,
+        -0.0003164021181873977,
+        -0.1190902441740036,
+        -1.9268131256103516,
+        -1.3252469301223755,
+        -6.232340335845947,
+        -6.316576957702637,
+        -0.5742834806442261,
+        -0.005311839282512665,
+        -1.9893786907196045,
+        -2.1285502910614014,
+        -6.269529342651367
+      ],
+      "max": [
+        5.681515216827393,
+        3.8880207538604736,
+        4.500889301300049,
+        1.789766788482666,
+        1.5632697343826294,
+        4.389739513397217,
+        1.3892723321914673,
+        3.242604970932007,
+        3.6588551998138428,
+        1.9530924558639526,
+        1.397123098373413,
+        3.503765106201172
+      ]
+    },
+    "observation.state.effector.position": {
+      "mean": [
+        0.6741562485694885,
+        0.6716748476028442
+      ],
+      "std": [
+        0.4518698453903198,
+        0.45221003890037537
+      ],
+      "q01": [
+        0.0,
+        0.0
+      ],
+      "q99": [
+        0.9997999668121338,
+        0.9997999668121338
+      ],
+      "q02": [
+        0.0,
+        0.0
+      ],
+      "q98": [
+        0.9997999668121338,
+        0.9997999668121338
+      ],
+      "min": [
+        0.0,
+        0.0
+      ],
+      "max": [
+        1.0,
+        1.0
+      ]
+    },
+    "action.arm.position": {
+      "mean": [
+        -0.2371421456336975,
+        1.1405216455459595,
+        0.8333077430725098,
+        -0.3407650291919708,
+        0.06622735410928726,
+        -0.06108175963163376,
+        0.26070570945739746,
+        1.2006030082702637,
+        0.8885032534599304,
+        -0.35232099890708923,
+        -0.01776392012834549,
+        0.0217923391610384
+      ],
+      "std": [
+        0.39080801606178284,
+        0.9996752142906189,
+        0.7989227771759033,
+        0.6973467469215393,
+        0.25976479053497314,
+        0.5871496796607971,
+        0.33891990780830383,
+        1.0239731073379517,
+        0.8191500306129456,
+        0.761202335357666,
+        0.2840091288089752,
+        0.6741793155670166
+      ],
+      "q01": [
+        -0.9676961898803711,
+        -0.0003164021181873977,
+        -0.0017427727580070496,
+        -1.6242835521697998,
+        -0.4315398335456848,
+        -2.308544158935547,
+        -0.16885042190551758,
+        -0.0017502307891845703,
+        -0.0009148390963673592,
+        -1.7149827480316162,
+        -1.1004638671875,
+        -1.7444939613342285
+      ],
+      "q99": [
+        0.2121286392211914,
+        2.5792064666748047,
+        2.4838061332702637,
+        1.340803861618042,
+        1.2559317350387573,
+        1.4261789321899414,
+        1.198167324066162,
+        2.6441168785095215,
+        2.5420172214508057,
+        1.3372783660888672,
+        1.1552619934082031,
+        2.2742843627929688
+      ],
+      "q02": [
+        -0.9286293983459473,
+        -0.0003164021181873977,
+        -0.0017427727580070496,
+        -1.5402888059616089,
+        -0.3321748971939087,
+        -1.8284258842468262,
+        -0.08562755584716797,
+        -0.0017502307891845703,
+        -0.0009148390963673592,
+        -1.6550571918487549,
+        -0.9650779962539673,
+        -1.5529375076293945
+      ],
+      "q98": [
+        0.1704568862915039,
+        2.4959962368011475,
+        2.3452067375183105,
+        1.210723638534546,
+        1.0468031167984009,
+        1.196742057800293,
+        0.9700741767883301,
+        2.5502209663391113,
+        2.393251895904541,
+        1.2678906917572021,
+        0.8041050434112549,
+        1.8462142944335938
+      ],
+      "min": [
+        -7.340834140777588,
+        -0.0003164021181873977,
+        -0.1190902441740036,
+        -1.9268131256103516,
+        -1.3252469301223755,
+        -6.232340335845947,
+        -6.316576957702637,
+        -0.5742834806442261,
+        -0.005311839282512665,
+        -1.9893786907196045,
+        -2.1285502910614014,
+        -6.269529342651367
+      ],
+      "max": [
+        5.681515216827393,
+        3.8880207538604736,
+        4.500889301300049,
+        1.789766788482666,
+        1.5632697343826294,
+        4.389739513397217,
+        1.3892723321914673,
+        3.242604970932007,
+        3.6588551998138428,
+        1.9530924558639526,
+        1.397123098373413,
+        3.503765106201172
+      ]
+    },
+    "action.effector.position": {
+      "mean": [
+        0.645467221736908,
+        0.6442767977714539
+      ],
+      "std": [
+        0.462748259305954,
+        0.4625539779663086
+      ],
+      "q01": [
+        0.0,
+        0.0
+      ],
+      "q99": [
+        0.9997999668121338,
+        0.9997999668121338
+      ],
+      "q02": [
+        0.0,
+        0.0
+      ],
+      "q98": [
+        0.9997999668121338,
+        0.9997999668121338
+      ],
+      "min": [
+        0.0,
+        0.0
+      ],
+      "max": [
+        1.0,
+        1.0
+      ]
+    }
+  },
+  "count": 495287
+}

scripts/e5_rollout_history.py

@@ -0,0 +1,134 @@
+"""E5 dual causal buffers: confirmed command prefix and prior public decisions.
+
+The caller invokes record_completed only after take_action returns and the public
+command counter advances. The cache never infers physical state from commands.
+Observe is called at the original 50-command decision boundaries. A reconnect
+invalidates both buffers until an explicit episode/session reset.
+"""
+from collections import deque
+import hashlib
+import json
+from pathlib import Path
+import numpy as np
+
+
+class RolloutCombinedHistory:
+    def __init__(self, episode_id, output=None, stride=50, session_id=None):
+        if stride != 50:
+            raise ValueError('E5 retains the 50-command execution protocol')
+        self.stride = stride
+        self.output = Path(output) if output else None
+        if self.output:
+            self.output.mkdir(parents=True, exist_ok=True)
+        self.reset(episode_id, session_id)
+
+    def reset(self, episode_id, session_id=None):
+        if episode_id is None:
+            raise ValueError('Explicit episode identity required')
+        self.episode_id = str(episode_id)
+        self.session_id = None if session_id is None else str(session_id)
+        self.commands = deque(maxlen=8)
+        self.completed_commands = 0
+        self.decisions = []
+        self.last_fields = None
+        self.invalidated = False
+        self.episode_output = None
+        if self.output:
+            identity = json.dumps([self.session_id, self.episode_id])
+            self.episode_output = self.output / hashlib.sha256(identity.encode()).hexdigest()
+            self.episode_output.mkdir(exist_ok=False)
+
+    def invalidate_on_reconnect(self):
+        self.commands.clear()
+        self.decisions.clear()
+        self.last_fields = None
+        self.invalidated = True
+
+    def _check_session(self, session_id):
+        if self.invalidated:
+            raise ValueError('Explicit episode reset required after reconnect')
+        session_id = None if session_id is None else str(session_id)
+        if session_id != self.session_id:
+            self.invalidate_on_reconnect()
+            raise ValueError('Session changed without explicit episode reset')
+
+    @staticmethod
+    def _counter(value):
+        if isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or value < 0:
+            raise ValueError('Expected nonnegative executed command counter')
+        return int(value)
+
+    def record_completed(self, commands, *, before_counter, after_counter, episode_id, session_id=None):
+        """Append only commands confirmed by the returned execution interval."""
+        self._check_session(session_id)
+        if str(episode_id) != self.episode_id:
+            raise ValueError('Episode changed without explicit reset')
+        before, after = self._counter(before_counter), self._counter(after_counter)
+        values = np.asarray(commands, dtype=np.float32)
+        if values.ndim != 2 or values.shape[1] != 14 or len(values) == 0 or not np.isfinite(values).all():
+            raise ValueError('Expected a nonempty finite executed command prefix of shape [N,14]')
+        if before != self.completed_commands or after-before != len(values):
+            raise ValueError('Execution confirmation must be contiguous and match the executed prefix')
+        if not self.decisions or after > self.decisions[-1][0]+self.stride:
+            raise ValueError('No current decision or command prefix exceeds frozen execution length')
+        for value in values:
+            self.commands.append(value.copy())
+        self.completed_commands = after
+
+    def _attach(self, observation):
+        actions, action_mask, states, state_mask = self.last_fields
+        return {**observation, 'action_history_raw': {'action': actions.copy()},
+            'action_history_mask': action_mask.copy(),
+            'state_history_raw': {'observation.state': states.copy()},
+            'state_history_mask': state_mask.copy()}
+
+    def observe(self, observation, action_counter, call=None, session_id=None):
+        self._check_session(session_id)
+        counter = self._counter(action_counter)
+        state = np.asarray(observation['observation.state'], dtype=np.float32).copy()
+        if state.shape != (14,) or not np.isfinite(state).all():
+            raise ValueError('Expected finite 14-dimensional public state; no command proxy substitution')
+        if counter != self.completed_commands:
+            raise ValueError('Observation counter differs from confirmed executed prefix')
+        if self.decisions and counter == self.decisions[-1][0]:
+            if not np.array_equal(state, self.decisions[-1][1]):
+                raise ValueError('Public state changed without executed command advance')
+            return self._attach(observation)
+        expected = self.decisions[-1][0]+self.stride if self.decisions else 0
+        if counter != expected:
+            raise ValueError('Decision interval/reset differs from frozen E5 protocol')
+        actions = np.zeros((8,14), dtype=np.float32)
+        action_mask = np.zeros(8, dtype=np.bool_)
+        if self.commands:
+            actions[-len(self.commands):] = np.stack(self.commands)
+            action_mask[-len(self.commands):] = True
+        states = np.zeros((2,14), dtype=np.float32)
+        state_mask = np.zeros(2, dtype=np.bool_)
+        recent = self.decisions[-2:]
+        for slot, (_, old_state) in enumerate(recent, start=2-len(recent)):
+            states[slot] = old_state
+            state_mask[slot] = True
+        self.last_fields = (actions.copy(), action_mask.copy(), states.copy(), state_mask.copy())
+        if self.output:
+            artifact = self.episode_output/('combined_history_%05d.npz' % counter)
+            np.savez_compressed(artifact, action_history_raw=actions, action_history_mask=action_mask,
+                state_history_raw=states, state_history_mask=state_mask, current_public_state=state)
+            with (self.episode_output/'combined_history_audit.jsonl').open('a') as handle:
+                handle.write(json.dumps(dict(episode_id=self.episode_id, session_id=self.session_id, call=call,
+                    completed_commands=counter, past_decision_counters=[x[0] for x in recent],
+                    valid_action_rows=int(action_mask.sum()), valid_state_rows=int(state_mask.sum()),
+                    action_history_sha256=hashlib.sha256(actions.tobytes()).hexdigest(),
+                    state_history_sha256=hashlib.sha256(states.tobytes()).hexdigest(),
+                    action_source='confirmed executed command prefix; action offset0 normalization',
+                    state_source='prior public observation.state; state normalization; not measured qpos',
+                    history_masks_independent=True))+'\n')
+        self.decisions.append((counter,state))
+        self.decisions = self.decisions[-2:]
+        return self._attach(observation)
+
+
+def empty_history():
+    return {'action_history_raw': {'action': np.zeros((8,14),dtype=np.float32)},
+            'action_history_mask': np.zeros(8,dtype=np.bool_),
+            'state_history_raw': {'observation.state': np.zeros((2,14),dtype=np.float32)},
+            'state_history_mask': np.zeros(2,dtype=np.bool_)}

scripts/eval_common.py

@@ -0,0 +1,135 @@
+"""Small, dependency-free persistence and whole-device NVML telemetry helpers."""
+import ctypes
+import json
+import os
+from pathlib import Path
+import threading
+import time
+import subprocess
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def save_json(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + '.tmp')
+    durable = os.environ.get('EVAL_DURABLE_WRITES') == '1'
+    with temporary.open('w') as stream:
+        stream.write(json.dumps(value, indent=2, ensure_ascii=False, default=str) + '\n')
+        if durable:
+            stream.flush()
+            os.fsync(stream.fileno())
+    os.replace(temporary, path)
+    if durable:
+        directory = os.open(str(path.parent), os.O_RDONLY | os.O_DIRECTORY)
+        try:
+            os.fsync(directory)
+        finally:
+            os.close(directory)
+
+
+def append_json(path, value):
+    with Path(path).open('a') as f:
+        f.write(json.dumps(value, ensure_ascii=False, default=str) + '\n')
+
+
+class MemoryInfo(ctypes.Structure):
+    _fields_ = [(name, ctypes.c_ulonglong) for name in ('total', 'free', 'used')]
+
+
+def nvml_device(nvml):
+    """Select the allocation UUID explicitly; CUDA masks do not remap NVML."""
+    handle = ctypes.c_void_p()
+    uuid = os.environ.get('EVAL_GPU_UUID')
+    if uuid:
+        if not uuid.startswith('GPU-') or ',' in uuid:
+            raise ValueError('EVAL_GPU_UUID must identify exactly one physical GPU')
+        code = nvml.nvmlDeviceGetHandleByUUID(uuid.encode(), ctypes.byref(handle))
+    else:
+        code = nvml.nvmlDeviceGetHandleByIndex_v2(0, ctypes.byref(handle))
+    if code:
+        raise RuntimeError(f'NVML device selection error {code}')
+    return handle
+
+
+class Telemetry:
+    def __init__(self, path):
+        self.path = Path(path)
+        self.nvml = ctypes.CDLL('libnvidia-ml.so.1')
+        self.check(self.nvml.nvmlInit_v2())
+        self.handle = nvml_device(self.nvml)
+        self.rows = []
+        self.lock = threading.Lock()
+        self.sample()
+        # A Python thread misses samples while simulator extensions hold the
+        # GIL during setup. A separate sampler process keeps a true 1 s cadence.
+        self.process = subprocess.Popen([sys.executable, str(Path(__file__).resolve()),
+                                         '--sample', str(self.path.resolve())],
+                                        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    @staticmethod
+    def check(code):
+        if code:
+            raise RuntimeError(f'NVML error {code}')
+
+    def sample(self):
+        with self.lock:
+            info = MemoryInfo()
+            code = self.nvml.nvmlDeviceGetMemoryInfo(self.handle, ctypes.byref(info))
+            row = {'monotonic': time.monotonic(), 'timestamp': time.time(), 'error': code}
+            if os.environ.get('EVAL_GPU_UUID'):
+                row['gpu_uuid'] = os.environ['EVAL_GPU_UUID']
+            if code == 0:
+                row['used_mib'] = info.used / 1024**2
+                row['total_mib'] = info.total / 1024**2
+            self.rows.append(row)
+            append_json(self.path, row)
+            return row
+
+    def summary(self, start, end):
+        if hasattr(self, 'path'):
+            sampled = []
+            for line in self.path.read_text().splitlines():
+                try:
+                    sampled.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass  # The only allowable partial line is the newest write.
+        else:
+            sampled = self.rows
+        rows = sorted([r for r in sampled if start <= r['monotonic'] <= end], key=lambda r:r['monotonic'])
+        integral = covered = 0.0
+        for a, b in zip(rows, rows[1:]):
+            dt = b['monotonic'] - a['monotonic']
+            if a['error'] or b['error'] or dt > 2.5:
+                continue
+            integral += (a['used_mib'] + b['used_mib']) * 0.5 * dt
+            covered += dt
+        good = [r['used_mib'] for r in rows if not r['error']]
+        return {'memory_integral_mib_seconds': integral,
+                'memory_covered_seconds': covered,
+                'memory_coverage': covered / (end-start) if end > start else 0,
+                'mean_memory_mib': integral / covered if covered else None,
+                'peak_memory_mib': max(good) if good else None,
+                'memory_samples': len(good)}
+
+    def close(self):
+        self.process.terminate()
+        self.process.wait(timeout=5)
+        self.sample()
+
+
+if __name__ == '__main__' and len(sys.argv) == 3 and sys.argv[1] == '--sample':
+    # Construct only the NVML reader, without recursively spawning a sampler.
+    reader = Telemetry.__new__(Telemetry)
+    reader.path = Path(sys.argv[2])
+    reader.nvml = ctypes.CDLL('libnvidia-ml.so.1')
+    reader.check(reader.nvml.nvmlInit_v2())
+    reader.handle = nvml_device(reader.nvml)
+    reader.rows = []
+    reader.lock = threading.Lock()
+    while True:
+        reader.sample()
+        reader.rows.clear()
+        time.sleep(1)

scripts/eval_device.py

@@ -0,0 +1,36 @@
+"""Opt-in explicit device binding for SAPIEN 3's legacy RoboTwin API."""
+import os
+
+
+def bind_sapien():
+    shader = os.environ.get('EVAL_RENDER_SHADER', 'rt')
+    if shader not in ('rt', 'default'):
+        raise ValueError('Supported evaluation shaders: rt or default')
+    if shader != 'rt':
+        import sapien
+        original_shader = sapien.render.set_camera_shader_dir
+        # Override only the official rt request. All physics/camera geometry and
+        # RNG remain unchanged; the new rendering protocol is recorded by the
+        # scheduler and must never be merged with local rt measurements.
+        def selected_shader(path):
+            return original_shader(shader if path == 'rt' else path)
+        sapien.render.set_camera_shader_dir = selected_shader
+    if not os.environ.get('EVAL_GPU_UUID'):
+        return
+    if os.environ.get('CUDA_VISIBLE_DEVICES') != os.environ['EVAL_GPU_UUID']:
+        raise RuntimeError('Simulator CUDA mask does not match the allocated GPU')
+    import sapien
+    device = sapien.Device('cuda:0')
+    if not device.is_cuda() or not device.can_render():
+        raise RuntimeError(f'Allocated GPU cannot render: {device}')
+    native_init = sapien.pysapien.render.SapienRenderer.__init__
+    sapien.SapienRenderer.__init__ = lambda self, **kw: native_init(self, device)
+    from sapien.wrapper.scene import Scene
+    original_init = Scene.__init__
+    def bound_scene(self, systems=None):
+        if systems is None:
+            systems = [sapien.physx.PhysxCpuSystem(), sapien.render.RenderSystem(device)]
+        original_init(self, systems)
+        if self.render_system.device.pci_string != device.pci_string:
+            raise RuntimeError('SAPIEN render device differs from allocation')
+    Scene.__init__ = bound_scene

scripts/eval_diagnostics.py

@@ -0,0 +1,71 @@
+"""Opt-in durable startup breadcrumbs, outside evaluated episode timings."""
+import faulthandler
+import json
+import os
+from pathlib import Path
+import signal
+import tempfile
+import time
+import traceback
+
+
+_states = {}
+_fault_handler_installed = False
+
+
+def _enable_fault_handler():
+    """Let the parent request all Python stacks before terminating a hang."""
+    global _fault_handler_installed
+    if not _fault_handler_installed:
+        faulthandler.enable(all_threads=True)
+        faulthandler.register(signal.SIGUSR1, all_threads=True)
+        _fault_handler_installed = True
+
+
+def emit_startup(output, phase, startup_complete=False, **details):
+    """Persist a startup phase for the external supervisor, when enabled."""
+    if os.environ.get('EVAL_STARTUP_DIAGNOSTICS') != '1':
+        return
+    _enable_fault_handler()
+    output = Path(output)
+    state = {**details, 'phase': phase, 'startup_complete': bool(startup_complete),
+             'timestamp': time.time(), 'monotonic': time.monotonic(), 'pid': os.getpid()}
+    output.mkdir(parents=True, exist_ok=True)
+    serialized = json.dumps(state, ensure_ascii=False, default=str) + '\n'
+    # An event may survive even if the node fails before the state replacement.
+    with (output / 'startup_events.jsonl').open('a') as stream:
+        stream.write(serialized)
+        stream.flush()
+        os.fsync(stream.fileno())
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', prefix='.startup_state.',
+                                         suffix='.tmp', dir=output, delete=False) as stream:
+            temporary = Path(stream.name)
+            stream.write(serialized)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, output / 'startup_state.json')
+        temporary = None
+        directory = os.open(output, os.O_RDONLY | os.O_DIRECTORY)
+        try:
+            os.fsync(directory)
+        finally:
+            os.close(directory)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+    _states[str(output.resolve())] = state
+    print(json.dumps({'event': 'startup_phase', **state}, ensure_ascii=False, default=str), flush=True)
+
+
+def record_startup_failure(output, error):
+    """Record early import/construction failures without relabeling rollout errors."""
+    if os.environ.get('EVAL_STARTUP_DIAGNOSTICS') != '1':
+        return
+    previous = _states.get(str(Path(output).resolve()), {})
+    if previous.get('startup_complete'):
+        return
+    emit_startup(output, 'startup_failed', failed_phase=previous.get('phase'),
+                 error_type=type(error).__name__, error=str(error),
+                 traceback=traceback.format_exc())

scripts/eval_model_registry.py

@@ -0,0 +1,66 @@
+"""Portable release identity adapter; original loading and rollout math are unchanged."""
+import hashlib
+import json
+import os
+from pathlib import Path
+
+MODEL_NAMES = ('e5',)
+
+
+def file_sha256(path):
+    digest = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(8*1024*1024), b''):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def profile(root):
+    epoch = os.environ.get('E5_EPOCH', '')
+    if epoch not in ('ep2', 'ep6'):
+        raise ValueError('Set E5_EPOCH to ep2 or ep6')
+    value = json.loads((Path(root)/'configs/evaluation'/(epoch+'.json')).read_text())
+    if value['epoch'] != int(epoch[2:]) or value['step'] != {'ep2':17180,'ep6':17178}[epoch]:
+        raise ValueError('Release identity mismatch')
+    return value
+
+
+def expected_metadata(root):
+    value = profile(root)
+    return {'checkpoint_source_kind':'original_public_e5_c3', 'repo_id':value['repo_id'],
+            'training_epoch':value['epoch'], 'training_step':value['step'],
+            'checkpoint_index_sha256':value['files']['model.safetensors.index.json']['sha256'],
+            'checkpoint_config_sha256':value['files']['config.json']['sha256'],
+            'checkpoint_files_verified':True, 'action_history_mode':'summary',
+            'action_history_length':8, 'action_history_mlp_hidden_size':1024,
+            'visual_history_mode':'none', 'state_history_mode':'tokens',
+            'state_history_length':2, 'state_history_stride':50}
+
+
+def verify_checkpoint(root):
+    root = Path(root)
+    value = profile(root)
+    checkpoint = root/'checkpoints'/('ep'+str(value['epoch']))
+    for name, expected in value['files'].items():
+        if Path(name).name != name:
+            raise ValueError('Invalid checkpoint filename')
+        path = checkpoint/name
+        if path.stat().st_size != expected['bytes'] or file_sha256(path) != expected['sha256']:
+            raise ValueError('Checkpoint file hash mismatch: '+name)
+    index = json.loads((checkpoint/'model.safetensors.index.json').read_text())
+    if len(index['weight_map']) != 1716 or set(index['weight_map'].values()) != {
+            f'model-{i:05d}-of-00006.safetensors' for i in range(1,7)}:
+        raise ValueError('Checkpoint tensor/shard membership mismatch')
+    norm = root/'manifests/norm_stats/robotwin_clean_train_s7.json'
+    if file_sha256(norm) != value['normalization_sha256']:
+        raise ValueError('Normalization identity mismatch')
+    return checkpoint,norm,expected_metadata(root)
+
+
+def validate_server_identity(metadata,root):
+    if any(metadata.get(k) != v for k,v in expected_metadata(root).items()):
+        raise ValueError('Server did not load the selected original release')
+
+
+def validate_lora_identity(metadata,root):
+    raise ValueError('This release supports original E5+C3 checkpoints only')

scripts/eval_official_worker.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""One RoboTwin task/setting process: shared expert seed preparation or policy eval.
+
+Uses the pinned official task classes, configuration, instructions, action mapping,
+chunk loop and success check. The adapter adds fixed seeds, timing and resumption.
+"""
+import argparse
+import importlib
+import json
+import os
+from pathlib import Path
+import random
+import signal
+import sys
+import time
+import traceback
+
+from eval_common import ROOT, Telemetry, append_json, save_json
+from eval_diagnostics import emit_startup, record_startup_failure
+
+ROBOTWIN = ROOT / 'third_party/RoboTwin'
+LINGBOT = ROOT / 'third_party/lingbot-vla-v2'
+os.environ['XDG_CACHE_HOME'] = str(ROOT / '.cache')
+os.environ['MPLCONFIGDIR'] = str(ROOT / '.cache/matplotlib')
+os.environ['TORCH_EXTENSIONS_DIR'] = str(ROOT / '.cache/torch_extensions_sim')
+
+
+def config(task, setting):
+    import yaml
+    root = ROBOTWIN / 'task_config'
+    cfg = yaml.safe_load((root / f'demo_{setting}.yml').read_text())
+    embodiment = yaml.safe_load((root / '_embodiment_config.yml').read_text())
+    cameras = yaml.safe_load((root / '_camera_config.yml').read_text())
+    assert cfg['embodiment'] == ['aloha-agilex']
+    robot_dir = embodiment['aloha-agilex']['file_path']
+    robot_cfg = yaml.safe_load((ROBOTWIN / robot_dir / 'config.yml').read_text())
+    camera = cameras[cfg['camera']['head_camera_type']]
+    cfg.update(task_name=task, task_config=f'demo_{setting}', eval_mode=True,
+               collect_data=False, save_data=False, render_freq=0, eval_video_log=False,
+               left_robot_file=robot_dir, right_robot_file=robot_dir, dual_arm_embodied=True,
+               left_embodiment_config=robot_cfg, right_embodiment_config=robot_cfg,
+               head_camera_h=camera['h'], head_camera_w=camera['w'])
+    return cfg
+
+
+def observation(env):
+    import numpy as np
+    obs = env.get_obs()
+    for name in ('head_camera', 'left_camera', 'right_camera'):
+        image = np.asarray(obs['observation'][name]['rgb'])
+        if image.shape != (240, 320, 3) or not np.isfinite(image).all() or image.std() == 0:
+            raise RuntimeError(f'Invalid camera observation: {name}, {image.shape}')
+    return {'observation.images.cam_high': obs['observation']['head_camera']['rgb'],
+            'observation.images.cam_left_wrist': obs['observation']['left_camera']['rgb'],
+            'observation.images.cam_right_wrist': obs['observation']['right_camera']['rgb'],
+            'observation.state': obs['joint_action']['vector'], 'task': env.get_instruction()}
+
+
+def restore_scene_sequence(env, row):
+    """Make resumed v1 scenes match the original uninterrupted 0..9 sequence.
+
+    Upstream get_cluttered_table mutates its x/y default lists in place on each
+    setup. Only these two tasks use a nonzero table offset. Passing fresh,
+    explicitly replayed bounds preserves the existing BF16 reference scenes,
+    including their upstream clutter drift, without depending on worker age.
+    This is v1 compatibility, NOT a correction of upstream scene generation.
+    """
+    if row['task'] not in ('dump_bin_bigbin', 'put_bottles_dustbin') or row['setting'] != 'randomized':
+        return {}
+    sequence_index = row.get('scene_sequence_index', row['index'])
+    if not 0 <= sequence_index < 10:
+        raise ValueError('Invalid frozen episode index')
+    # Addition order matters: reproduce each preceding setup's exact floats.
+    xlim, ylim = [-0.59, 0.59], [-0.34, 0.34]
+    for _ in range(sequence_index):
+        xlim[0] += 0.3
+        xlim[1] += 0.3
+    from envs._base_task import Base_Task
+    def frozen_clutter():
+        if list(env.table_xy_bias) != [0.3, 0]:
+            raise RuntimeError('Unexpected table offset for v1 scene restoration')
+        return Base_Task.get_cluttered_table(env, xlim=xlim.copy(), ylim=ylim.copy(), zlim=[0.741])
+    env.get_cluttered_table = frozen_clutter
+    return {'protocol': 'v1_uninterrupted_cell_sequence',
+            'prior_setups': sequence_index, 'xlim_before_setup': xlim, 'ylim_before_setup': ylim}
+
+
+def restore_task_state(env, row):
+    """Restore deterministic pre-action fields normally left by play_once.
+
+    The official client reuses its expert environment for policy evaluation.
+    Our separate workers must recreate these three tasks' success-check inputs
+    after EVERY setup, including later episodes in the same worker.
+    """
+    task = row['task']
+    if task not in ('open_laptop', 'place_object_scale', 'put_object_cabinet'):
+        return {}
+    from envs.utils import ArmTag, get_face_prod
+    if task == 'open_laptop':
+        face_prod = get_face_prod(env.laptop.get_pose().q, [1, 0, 0], [1, 0, 0])
+        arm = 'left' if face_prod > 0 else 'right'
+    else:
+        arm = 'right' if env.object.get_pose().p[0] > 0 else 'left'
+    if arm != row['scene_info']['{a}']:
+        raise RuntimeError(f'Expert/policy scene arm mismatch: {task}, seed {row["seed"]}')
+    env.arm_tag = ArmTag(arm)
+    state = {'arm_tag': arm}
+    if task == 'put_object_cabinet':
+        env.origin_z = env.object.get_pose().p[2]
+        state['origin_z'] = float(env.origin_z)
+    return state
+
+
+def release_unused_cuda_cache(env):
+    # Return expert-only allocations before Vulkan allocates render targets.
+    import gc
+    import pickle
+    import torch
+    import numpy as np
+    def snapshot():
+        return pickle.dumps((env.robot.get_left_arm_jointState(), env.robot.get_right_arm_jointState(),
+                             [(a.get_name(), a.get_pose().p.tolist(), a.get_pose().q.tolist())
+                              for a in env.scene.get_all_actors()], np.random.get_state(), random.getstate()))
+    initial = snapshot()
+    before = torch.cuda.memory_reserved()
+    # All experts ran in a separate preparation process. Joint-position policy
+    # execution needs MPlib TOPP and the CPU gripper interpolation only, not
+    # CuRobo MotionGen or its CUDA graphs. Preserve planner objects/metadata so
+    # Robot.reset and the exact official gripper function remain unchanged.
+    if env.robot.communication_flag:
+        raise RuntimeError('Expert-engine release is only validated for in-process Aloha planners')
+    def unavailable(*a, **kw):
+        raise RuntimeError('Policy rollout unexpectedly requested expert GPU planning')
+    for planner in (env.robot.left_planner, env.robot.right_planner):
+        for key in ('motion_gen', 'motion_gen_batch'):
+            if hasattr(planner, key):
+                delattr(planner, key)
+        planner.plan_path = unavailable
+        planner.plan_batch = unavailable
+    gc.collect()
+    torch.cuda.empty_cache()
+    if snapshot() != initial:
+        raise RuntimeError('Expert-engine release changed scene, joints or random state')
+    print(json.dumps({'event': 'release_unused_sim_cache',
+                      'reserved_before_mib': before/1024**2,
+                      'reserved_after_mib': torch.cuda.memory_reserved()/1024**2,
+                      'scene_joint_rng_unchanged': True}), flush=True)
+
+
+def prepare(args, env, cfg):
+    from envs.utils.create_actor import UnStableError
+    from generate_episode_instructions import generate_episode_descriptions
+    import numpy as np
+    path = args.manifest_dir / f'{args.task}__{args.setting}.json'
+    if path.exists():
+        previous = json.loads(path.read_text())
+        if previous['status'] == 'ready' and len(previous['episodes']) == 10:
+            print('Reusing frozen seed manifest', path, flush=True)
+            return
+        raise RuntimeError('Partial manifest exists; inspect before replacing')
+    result = {'task': args.task, 'setting': args.setting, 'status': 'preparing',
+              'start_seed': args.start_seed, 'candidate_limit': 200,
+              'instruction_type': 'unseen', 'episodes': [], 'rejections': [],
+              'policy_evaluation_during_selection': False}
+    started = time.monotonic()
+    try:
+        for seed in range(args.start_seed, args.start_seed+200):
+            signal.alarm(240)
+            t = time.monotonic()
+            random.seed(seed)
+            expert_error = None
+            try:
+                env.setup_demo(now_ep_num=len(result['episodes']), seed=seed, is_test=True, **cfg)
+                try:
+                    info = env.play_once()
+                except (TypeError, ValueError, IndexError, AssertionError) as error:
+                    # The official client rejects candidates when expert planning
+                    # raises (e.g. no feasible grasp returns None). Keep setup,
+                    # asset, timeout, CUDA and Vulkan errors fatal; bound candidate
+                    # selection and retain the exact expert failure for audit.
+                    expert_error = {'type': type(error).__name__, 'message': str(error),
+                                    'traceback': traceback.format_exc()}
+                env.close_env()
+                accepted = expert_error is None and bool(env.plan_success and env.check_success())
+                reason = ('expert_exception' if expert_error is not None else
+                          None if accepted else 'expert_plan_or_success_failed')
+            except UnStableError as error:
+                accepted, reason = False, str(error)
+                env.close_env()
+            if accepted:
+                # Instruction draw is fixed independently from policy inference RNG.
+                random.seed(seed+9107)
+                descriptions = generate_episode_descriptions(args.task, [info['info']], 10)
+                if not descriptions or not descriptions[0]['unseen']:
+                    raise RuntimeError('No unseen instructions')
+                instruction = str(np.random.RandomState(seed+9107).choice(descriptions[0]['unseen']))
+                row = {'task': args.task, 'setting': args.setting, 'index': len(result['episodes']),
+                       'seed': seed, 'policy_seed': seed+42, 'instruction': instruction,
+                       'scene_info': info['info'], 'precheck_seconds': time.monotonic()-t}
+                result['episodes'].append(row)
+            else:
+                result['rejections'].append({'seed': seed, 'reason': reason, 'seconds': time.monotonic()-t,
+                                             **({'expert_error': expert_error} if expert_error else {})})
+            signal.alarm(0)
+            print(json.dumps({'seed': seed, 'accepted': accepted, 'count': len(result['episodes']),
+                              'seconds': time.monotonic()-t}), flush=True)
+            save_json(args.output / 'precheck_progress.json', result)
+            if len(result['episodes']) == 10:
+                break
+        if len(result['episodes']) != 10:
+            raise RuntimeError('Fewer than 10 valid seeds within 200 candidates')
+        result['status'] = 'ready'
+        result['seconds'] = time.monotonic()-started
+        save_json(path, result)
+    finally:
+        signal.alarm(0)
+
+
+def evaluate(args, env, cfg):
+    emit_startup(args.output, 'evaluation_imports_started')
+    import numpy as np
+    from deploy.websocket_client_policy import WebsocketClientPolicy
+    emit_startup(args.output, 'evaluation_imports_complete')
+    manifest = json.loads((args.manifest_dir / f'{args.task}__{args.setting}.json').read_text())
+    assert manifest['status'] == 'ready' and len(manifest['episodes']) == 10
+    rows = manifest['episodes']
+    if args.indices:
+        wanted = {int(i) for i in args.indices.split(',')}
+        rows = [r for r in rows if r['index'] in wanted]
+    emit_startup(args.output, 'policy_client_connecting', port=args.port)
+    model = WebsocketClientPolicy(host='127.0.0.1', port=args.port)
+    metadata = model.get_server_metadata()
+    assert metadata['model'] == args.model and metadata['precision'] == args.precision, metadata
+    save_json(args.output / 'server_metadata.json', metadata)
+    emit_startup(args.output, 'policy_client_ready', model=args.model, precision=args.precision)
+    emit_startup(args.output, 'telemetry_initializing')
+    telemetry = Telemetry(args.output / 'gpu_samples.jsonl')
+    completed = []
+    try:
+        emit_startup(args.output, 'worker_ready', startup_complete=True)
+        for row in rows:
+            args.output.mkdir(parents=True, exist_ok=True)
+            record_path = args.results_dir / f"{args.model}_{args.precision}" / f"{args.task}__{args.setting}__{row['index']:02d}.json"
+            if record_path.exists():
+                saved = json.loads(record_path.read_text())
+                assert saved['seed'] == row['seed'] and saved['status'] == 'completed'
+                continue
+            signal.alarm(900)
+            random.seed(row['seed'])
+            boundary = telemetry.sample()
+            start = boundary['monotonic']
+            append_json(args.output / 'events.jsonl', {'event': 'episode_started', 'timestamp': time.time(), **row})
+            scene_sequence = restore_scene_sequence(env, row)
+            env.setup_demo(now_ep_num=row['index'], seed=row['seed'], is_test=True, **cfg)
+            restored_state = restore_task_state(env, row)
+            release_unused_cuda_cache(env)
+            env.set_instruction(instruction=row['instruction'])
+            model.infer(dict(reset=True, robo_name='robotwin', policy_seed=row['policy_seed']))
+            rollout_start = time.monotonic()
+            success = False
+            calls = 0
+            latencies = []
+            while env.take_action_cnt < env.step_lim and not success:
+                obs = observation(env)
+                call_start = time.monotonic()
+                response = model.infer(obs)
+                latencies.append(time.monotonic()-call_start)
+                calls += 1
+                actions = np.asarray(response['action'])
+                if actions.shape != (50, 14) or not np.isfinite(actions).all():
+                    raise RuntimeError(f'Invalid actions: {actions.shape}')
+                for action in actions:
+                    if env.take_action_cnt >= env.step_lim:
+                        break
+                    env.take_action(action)
+                    if env.eval_success:
+                        success = True
+                        break
+            rollout_seconds = time.monotonic()-rollout_start
+            action_count, step_limit = env.take_action_cnt, env.step_lim
+            env.close_env(clear_cache=((row['index']+1) % cfg['clear_cache_freq'] == 0))
+            end = telemetry.sample()['monotonic']
+            result = {**row, 'model': args.model, 'precision': args.precision,
+                      'status': 'completed', 'success': success,
+                      'episode_wall_seconds': end-start, 'rollout_seconds': rollout_seconds,
+                      'actions': action_count, 'step_limit': step_limit, 'policy_calls': calls,
+                      'mean_policy_request_seconds': sum(latencies)/len(latencies),
+                      'monotonic_start': start, 'monotonic_end': end,
+                      'finished_at': time.time(), 'attempt_dir': str(args.output),
+                      'video': False, 'expert_gpu_engines_released': True,
+                      'render_shader': os.environ.get('EVAL_RENDER_SHADER', 'rt'),
+                      'evaluation_protocol': os.environ.get('EVAL_PROTOCOL', 'local_v1_rt'),
+                      'restored_task_state': restored_state,
+                      'restored_scene_sequence': scene_sequence,
+                      **telemetry.summary(start, end)}
+            if result['memory_coverage'] < 0.98:
+                raise RuntimeError(f'Insufficient telemetry coverage: {result["memory_coverage"]}')
+            save_json(record_path, result)
+            append_json(args.output / 'events.jsonl', {'event': 'episode_finished', **result})
+            completed.append(result)
+            print(json.dumps({'event': 'episode_finished', **result}), flush=True)
+            signal.alarm(0)
+        save_json(args.output / 'result.json', {'status': 'completed', 'episodes': completed})
+    finally:
+        telemetry.close()
+        signal.alarm(0)
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--mode', choices=['prepare', 'evaluate'], required=True)
+    p.add_argument('--task', required=True)
+    p.add_argument('--setting', choices=['clean', 'randomized'], required=True)
+    p.add_argument('--start-seed', type=int, default=300000)
+    p.add_argument('--output', type=Path, required=True)
+    p.add_argument('--manifest-dir', type=Path, required=True)
+    p.add_argument('--results-dir', type=Path)
+    p.add_argument('--model', choices=['base', 'robotwin'])
+    p.add_argument('--precision', choices=['bf16', 'fp32'])
+    p.add_argument('--port', type=int, default=9340)
+    p.add_argument('--indices')
+    args = p.parse_args()
+    args.output = args.output.resolve()
+    args.manifest_dir = args.manifest_dir.resolve()
+    args.results_dir = args.results_dir.resolve() if args.results_dir else None
+    args.output.mkdir(parents=True, exist_ok=True)
+    args.manifest_dir.mkdir(parents=True, exist_ok=True)
+    def timeout(signum, frame):
+        raise TimeoutError('Per-seed/precheck or episode timeout')
+    env = None
+    try:
+        emit_startup(args.output, 'python_entry', role='worker', task=args.task,
+                     setting=args.setting, mode=args.mode)
+        signal.signal(signal.SIGALRM, timeout)
+        os.chdir(ROBOTWIN)
+        sys.path[:0] = [str(ROBOTWIN), str(ROBOTWIN/'description/utils'), str(LINGBOT)]
+        emit_startup(args.output, 'sapien_binding_started')
+        from eval_device import bind_sapien
+        bind_sapien()
+        emit_startup(args.output, 'sapien_binding_complete')
+        emit_startup(args.output, 'task_import_started', task=args.task)
+        cls = getattr(importlib.import_module('envs.'+args.task), args.task)
+        emit_startup(args.output, 'task_import_complete')
+        emit_startup(args.output, 'environment_constructing')
+        env = cls()
+        emit_startup(args.output, 'environment_constructed')
+        emit_startup(args.output, 'config_loading')
+        cfg = config(args.task, args.setting)
+        emit_startup(args.output, 'config_loaded')
+        if args.mode == 'prepare':
+            emit_startup(args.output, 'preparation_ready', startup_complete=True)
+            prepare(args, env, cfg)
+        else:
+            evaluate(args, env, cfg)
+    except BaseException as error:
+        record_startup_failure(args.output, error)
+        save_json(args.output / 'error.json', {'type': type(error).__name__, 'message': str(error),
+                                             'traceback': traceback.format_exc(), 'timestamp': time.time()})
+        raise
+    finally:
+        signal.alarm(0)
+        try:
+            env.close_env()
+        except Exception:
+            pass
+        robot = getattr(env, 'robot', None)
+        for key in ('left_proc', 'right_proc'):
+            process = getattr(robot, key, None)
+            if process is not None and process.is_alive():
+                process.terminate()
+                process.join(timeout=5)
+                if process.is_alive():
+                    process.kill()
+                    process.join()
+
+
+if __name__ == '__main__':
+    main()

scripts/eval_planner_optimization.py

@@ -0,0 +1,223 @@
+"""Skip unused expert CUDA engines in the supported hybrid evaluation path.
+
+This does not replace CuRobo's planner class or its CPU gripper interpolation.
+Only construction is temporarily changed; MPlib TOPP and the simulation are
+untouched. Expert seed selection must continue to use the legacy constructor.
+
+CuRobo warmup consumes CUDA random numbers. Omitting it intentionally changes
+the local CUDA RNG state, so the optimized path is restricted to RGB/qpos
+rollouts with policy inference in a separate process. It is not a general
+replacement for the planner, nor a claim that all RNG states are identical.
+"""
+from contextlib import contextmanager
+import hashlib
+import importlib
+import inspect
+from pathlib import Path
+import threading
+import time
+
+
+PLANNER_SETUP_MODES = ('legacy', 'skip_unused')
+OPTIMIZATION_VERSION = 'hybrid_rgb_qpos_skip_curobo_v1'
+_PATCH_LOCK = threading.Lock()
+
+
+def _expert_planning_unavailable(*args, **kwargs):
+    raise RuntimeError('Expert CuRobo planning is unavailable in optimized RGB/qpos '
+                       'evaluation; use planner setup mode legacy for expert planning')
+
+
+def _validate_configuration(cfg, action_type, policy_execution):
+    """Reject unvalidated paths before touching the upstream planner class."""
+    if cfg.get('eval_mode') is not True:
+        raise ValueError('Planner optimization requires eval_mode=True')
+    if cfg.get('collect_data') is not False or cfg.get('save_data') is not False:
+        raise ValueError('Planner optimization cannot be used for expert data collection')
+    if action_type != 'qpos':
+        raise ValueError('Planner optimization only supports qpos actions')
+    if policy_execution != 'remote':
+        raise ValueError('Planner optimization requires separate-process remote policy inference')
+    if cfg.get('embodiment') != ['aloha-agilex'] or cfg.get('dual_arm_embodied') is not True:
+        raise ValueError('Planner optimization only supports dual-arm aloha-agilex')
+    if cfg.get('domain_randomization', {}).get('random_embodiment', False):
+        raise ValueError('Random embodiment is unsupported by planner optimization')
+    left_path, right_path = cfg.get('left_robot_file'), cfg.get('right_robot_file')
+    # Robot.set_planner compares the original path strings to choose IPC, before
+    # appending the arm-specific YAML name. Match that exact decision here.
+    if not isinstance(left_path, str) or left_path != right_path:
+        raise ValueError('Planner optimization requires identical in-process robot paths')
+    robot_path = Path(left_path).resolve()
+    if robot_path.name != 'aloha-agilex':
+        raise ValueError('Planner optimization requires the aloha-agilex robot directory')
+    left = cfg.get('left_embodiment_config', {})
+    right = cfg.get('right_embodiment_config', {})
+    if left != right or left.get('planner') != 'curobo' or left.get('dual_arm') is not True:
+        raise ValueError('Planner optimization requires matching official Aloha CuRobo configurations')
+    expected_joints = [[f'{prefix}_joint{i}' for i in range(1, 7)]
+                       for prefix in ('fl', 'fr')]
+    if left.get('arm_joints_name') != expected_joints:
+        raise ValueError('Unsupported Aloha arm joint configuration')
+    data = cfg.get('data_type', {})
+    if data.get('rgb') is not True or data.get('qpos') is not True:
+        raise ValueError('Planner optimization requires RGB and qpos observations')
+    if data.get('pointcloud') is not False:
+        raise ValueError('Pointcloud observations are unsupported by planner optimization')
+    for key in ('depth', 'third_view', 'observer', 'mesh_segmentation', 'actor_segmentation'):
+        if data.get(key, False):
+            raise ValueError(f'Unsupported observation channel for planner optimization: {key}')
+    return robot_path, expected_joints
+
+
+class _PlannerSetupEvidence:
+    def __init__(self, mode):
+        self.mode = mode
+        self.instances = []
+        self.initializations = []
+        self.verified = False
+        self.class_restored = mode == 'legacy'
+        self.source_sha256 = None
+        self.planner_class = None
+        self.gripper_method = None
+        self.reused_instances = 0
+
+    def verify_environment(self, env):
+        """Check the actual setup, including IPC and the retained TOPP engines."""
+        if self.mode == 'legacy':
+            if any(getattr(getattr(env.robot, f'{side}_planner', None),
+                           '_hybrid_planner_optimization_version', None)
+                   for side in ('left', 'right')):
+                raise RuntimeError('Legacy mode requires a fresh environment after optimized setup')
+            self.verified = True
+            return
+        robot = env.robot
+        if getattr(env, 'eval_mode', None) is not True:
+            raise RuntimeError('Environment left evaluation mode during setup')
+        if getattr(robot, 'communication_flag', None) is not False:
+            raise RuntimeError('Optimized evaluation unexpectedly used planner IPC')
+        if getattr(robot, 'is_dual_arm', None) is not True:
+            raise RuntimeError('Optimized evaluation requires the dual-arm robot')
+        if getattr(robot, 'need_topp', None) is not True:
+            raise RuntimeError('Optimized qpos evaluation requires official MPlib TOPP')
+        planners = (robot.left_planner, robot.right_planner)
+        if planners[0] is planners[1]:
+            raise RuntimeError('Expected exactly two distinct CuRobo planners')
+        if self.instances and (len(self.instances) != 2 or
+                               set(map(id, planners)) != set(map(id, self.instances))):
+            raise RuntimeError('Expected exactly two initialized in-process CuRobo planners')
+        for planner in planners:
+            if type(planner) is not self.planner_class:
+                raise RuntimeError('Upstream CuRobo planner type changed during setup')
+            if hasattr(planner, 'motion_gen') or hasattr(planner, 'motion_gen_batch'):
+                raise RuntimeError('Expert CUDA engine was unexpectedly initialized')
+            if getattr(planner, '_hybrid_planner_optimization_version', None) != OPTIMIZATION_VERSION:
+                raise RuntimeError('Existing planner was not constructed by this optimization')
+            if planner.plan_path is not _expert_planning_unavailable or planner.plan_batch is not _expert_planning_unavailable:
+                raise RuntimeError('Expert planning guard was replaced during setup')
+            if 'plan_grippers' in vars(planner) or type(planner).plan_grippers is not self.gripper_method:
+                raise RuntimeError('Official gripper interpolation changed during setup')
+        for side in ('left', 'right'):
+            if not callable(getattr(getattr(robot, f'{side}_mplib_planner', None), 'TOPP', None)):
+                raise RuntimeError(f'Missing official {side} MPlib TOPP engine')
+        if not self.instances:
+            self.reused_instances = 2
+        self.verified = True
+
+    def provenance(self):
+        return {
+            'mode': self.mode,
+            'version': OPTIMIZATION_VERSION,
+            'scope': 'remote_policy_rgb_qpos_aloha_evaluation',
+            'environment_verified': self.verified,
+            'constructor_restored': self.class_restored,
+            'planner_instances_skipped': len(self.instances),
+            'planner_instances_reused': self.reused_instances,
+            'expert_motiongen_engines_skipped': len(self.instances) * 2,
+            'initializations': list(self.initializations),
+            'upstream_planner_source_sha256': self.source_sha256,
+            'local_cuda_rng_matches_legacy': self.mode == 'legacy',
+            'cuda_rng_note': ('Unchanged legacy constructor' if self.mode == 'legacy' else
+                             'CuRobo warmup CUDA RNG draws are omitted; remote policy noise is independent'),
+            'gripper_interpolation': 'official_unchanged',
+            'qpos_trajectory': 'official_MPlib_TOPP_unchanged',
+        }
+
+
+@contextmanager
+def evaluation_planner_setup(cfg, *, mode, action_type='qpos', policy_execution='remote',
+                             _planner_module=None):
+    """Scope constructor substitution to one fresh hybrid environment setup.
+
+    Call ``evidence.verify_environment(env)`` after ``env.setup_demo`` inside
+    this context. A normal exit without verification is an error. Exceptions
+    always restore the original constructor, but the created planner instances
+    retain fail-closed expert planning guards for their entire lifetime.
+
+    ``_planner_module`` is a CPU-test seam, not a production configuration flag.
+    The explicit ``legacy`` mode performs no import or patch and is suitable for
+    comparisons and rollback.
+    """
+    if mode not in PLANNER_SETUP_MODES:
+        raise ValueError(f'Unknown planner setup mode: {mode}')
+    evidence = _PlannerSetupEvidence(mode)
+    if mode == 'legacy':
+        yield evidence
+        return
+    robot_path, expected_joints = _validate_configuration(cfg, action_type, policy_execution)
+    if threading.current_thread() is not threading.main_thread():
+        raise RuntimeError('Planner setup substitution is only supported in the main thread')
+    if not _PATCH_LOCK.acquire(blocking=False):
+        raise RuntimeError('Nested or concurrent planner setup substitution is unsupported')
+    original_init = planner_class = None
+    try:
+        module = _planner_module or importlib.import_module('envs.robot.planner')
+        planner_class = module.CuroboPlanner
+        original_init = planner_class.__init__
+        evidence.planner_class = planner_class
+        evidence.gripper_method = planner_class.plan_grippers
+        source = inspect.getsourcefile(planner_class)
+        if source and Path(source).is_file():
+            evidence.source_sha256 = hashlib.sha256(Path(source).read_bytes()).hexdigest()
+
+        def minimal_init(self, robot_origion_pose, active_joints_name, all_joints, yml_path=None):
+            started = time.monotonic()
+            if yml_path is None:
+                raise ValueError('Optimized planner requires its official arm YAML path')
+            yaml_path = Path(yml_path).resolve()
+            filenames = ('curobo_left.yml', 'curobo_right.yml')
+            if yaml_path.parent != robot_path or yaml_path.name not in filenames:
+                raise ValueError(f'Unexpected optimized planner configuration: {yaml_path}')
+            arm_index = filenames.index(yaml_path.name)
+            if list(active_joints_name) != expected_joints[arm_index]:
+                raise ValueError('Unexpected active joints in optimized planner construction')
+            if not set(active_joints_name).issubset(all_joints):
+                raise ValueError('Optimized planner joint names are absent from the robot')
+            if len(evidence.instances) >= 2:
+                raise RuntimeError('Unexpected extra CuRobo planner initialization')
+            # Keep original class identity and official CPU-only methods. Guard
+            # expert calls immediately, including ones accidentally made by setup.
+            self.plan_path = _expert_planning_unavailable
+            self.plan_batch = _expert_planning_unavailable
+            self._hybrid_planner_optimization_version = OPTIMIZATION_VERSION
+            module.ta.setup_logging('CRITICAL')
+            module.logger.setup_logger(level='error', logger_name="'curobo")
+            self.yml_path = yml_path
+            self.robot_origion_pose = robot_origion_pose
+            self.active_joints_name = active_joints_name
+            self.all_joints = all_joints
+            with open(yml_path) as stream:
+                self.frame_bias = module.yaml.safe_load(stream)['planner']['frame_bias']
+            evidence.instances.append(self)
+            evidence.initializations.append({'arm': ('left', 'right')[arm_index],
+                                             'yml_path': str(yaml_path),
+                                             'seconds': time.monotonic() - started})
+
+        planner_class.__init__ = minimal_init
+        yield evidence
+        if not evidence.verified:
+            raise RuntimeError('Optimized environment was not verified after setup')
+    finally:
+        if original_init is not None:
+            planner_class.__init__ = original_init
+            evidence.class_restored = True
+        _PATCH_LOCK.release()

scripts/frozen_eval_subset.py

@@ -0,0 +1,198 @@
+"""Validate an independent, checksummed closed-loop evaluation package.
+
+The legacy v1/10k loaders stay separate. A published package records its actual
+Git commit, rather than inheriting the legacy v1 commit or trusting a label.
+"""
+from collections import Counter
+from dataclasses import dataclass
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+import subprocess
+
+
+def sha256(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def _read(path):
+    return json.loads(Path(path).read_text())
+
+
+def _package_files(root):
+    files = {}
+    for path in root.rglob('*'):
+        relative = path.relative_to(root)
+        if '__pycache__' in relative.parts or path.suffix == '.pyc':
+            continue
+        if path.is_symlink():
+            raise ValueError('Package files must not be symlinks: ' + str(relative))
+        if path.is_file():
+            files[relative.as_posix()] = path
+    return files
+
+
+def verify_checksums(directory):
+    root = Path(directory).resolve()
+    files = _package_files(root)
+    if 'SHA256SUMS' not in files:
+        raise ValueError('Frozen package requires SHA256SUMS')
+    expected = {}
+    for line in files['SHA256SUMS'].read_text().splitlines():
+        match = re.fullmatch(r'([0-9a-f]{64}) [ *](.+)', line)
+        if not match:
+            raise ValueError('Malformed SHA256SUMS line')
+        digest, name = match.groups()
+        path = PurePosixPath(name)
+        if path.is_absolute() or '..' in path.parts or path.as_posix() != name or name == 'SHA256SUMS':
+            raise ValueError('Unsafe or recursive checksum path: ' + name)
+        if name in expected:
+            raise ValueError('Duplicate checksum path: ' + name)
+        expected[name] = digest
+    if set(expected) != set(files) - {'SHA256SUMS'}:
+        raise ValueError('SHA256SUMS must cover every package file exactly')
+    for name, digest in expected.items():
+        if sha256(files[name]) != digest:
+            raise ValueError('Package checksum mismatch: ' + name)
+    return root, files, expected
+
+
+def _published_commit(root, files):
+    def git(*args, cwd=root):
+        try:
+            return subprocess.run(['git', '-C', str(cwd), *args], check=True,
+                                  stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout
+        except subprocess.CalledProcessError as error:
+            raise ValueError('Package must be in a published Git checkout') from error
+    top = Path(git('rev-parse', '--show-toplevel').decode().strip()).resolve()
+    prefix = root.relative_to(top).as_posix()
+    commit = git('log', '-1', '--format=%H', '--', '.').decode().strip()
+    if not re.fullmatch('[0-9a-f]{40}', commit):
+        raise ValueError('Package has no committed publication')
+    # git status can be defeated by assume-unchanged/skip-worktree. Compare each
+    # actual byte sequence with the committed Git blob instead.
+    # --full-tree resets ls-tree's pathspec base. Query explicitly from the
+    # repository top using this package's path, excluding unrelated files.
+    tree = git('ls-tree', '-r', '-z', '--full-tree', commit, '--', prefix, cwd=top)
+    tracked = {}
+    for item in tree.split(b'\0'):
+        if not item:
+            continue
+        metadata, raw_name = item.split(b'\t', 1)
+        mode, kind, digest = metadata.decode().split()
+        name = raw_name.decode()
+        relative = str(PurePosixPath(name).relative_to(prefix)) if prefix != '.' else name
+        if '__pycache__' in PurePosixPath(relative).parts or relative.endswith('.pyc'):
+            continue
+        if kind != 'blob' or mode not in ('100644', '100755'):
+            raise ValueError('Publication contains nonregular package files')
+        tracked[relative] = digest
+    if set(tracked) != set(files):
+        raise ValueError('Package file set differs from its Git publication')
+    for name, path in files.items():
+        raw = path.read_bytes()
+        blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest()
+        if blob != tracked[name]:
+            raise ValueError('Package differs from its Git publication: ' + name)
+    return commit
+
+
+@dataclass(frozen=True)
+class FrozenSubset:
+    directory: Path
+    protocol: dict
+    plan: list
+    commit: str | None
+    checksums_sha256: str
+    protocol_sha256: str
+
+    @property
+    def manifest_dir(self):
+        return self.directory / 'seed_manifests'
+
+    @property
+    def identity(self):
+        return {'subset_id': self.protocol['subset_id'],
+                'runtime_protocol': self.protocol['runtime_protocol'],
+                'subset_commit': self.commit,
+                'count': self.protocol['count'],
+                'checksums_sha256': self.checksums_sha256,
+                'protocol_sha256': self.protocol_sha256,
+                'episodes_sha256': self.protocol['episodes_sha256']}
+
+
+def load_subset(directory, *, require_published=True):
+    root, files, checksums = verify_checksums(directory)
+    for required in ('protocol.json', 'episodes.jsonl'):
+        if required not in files:
+            raise ValueError('Missing package identity: ' + required)
+    protocol = _read(files['protocol.json'])
+    if not re.fullmatch(r'[a-z0-9][a-z0-9_-]+', protocol.get('subset_id', '')):
+        raise ValueError('Invalid subset_id')
+    if not re.fullmatch(r'hybrid_[a-z0-9_]+_rt', protocol.get('runtime_protocol', '')):
+        raise ValueError('Invalid RT runtime protocol')
+    dimensions = [protocol.get(key) for key in ('count', 'tasks', 'episodes_per_task_setting')]
+    if any(type(value) is not int or value <= 0 for value in dimensions):
+        raise ValueError('Protocol must declare positive integer quotas')
+    count, task_count, quota = dimensions
+    settings = protocol.get('settings')
+    if (not isinstance(settings, list) or not settings or len(set(settings)) != len(settings)
+            or not set(settings) <= {'clean', 'randomized'}
+            or count != task_count * len(settings) * quota):
+        raise ValueError('Invalid setting quota or total count')
+    instruction_types = protocol.get('instruction_types')
+    if (not isinstance(instruction_types, dict) or set(instruction_types) != set(settings)
+            or not set(instruction_types.values()) <= {'seen', 'unseen'}):
+        raise ValueError('Protocol must declare an instruction type for each setting')
+    if protocol.get('episodes_sha256') != checksums['episodes.jsonl']:
+        raise ValueError('Protocol episodes SHA256 does not match package')
+    rows = [json.loads(line) for line in files['episodes.jsonl'].read_text().splitlines()]
+    expected = {}
+    for row in rows:
+        if (not re.fullmatch(r'[a-z][a-z0-9_]*', row.get('task', ''))
+                or row.get('setting') not in settings or type(row.get('index')) is not int
+                or not 0 <= row['index'] < quota
+                or any(type(row.get(key)) is not int or row[key] < 0 for key in ('seed', 'policy_seed'))
+                or not isinstance(row.get('instruction'), str) or not row['instruction'].strip()
+                or not isinstance(row.get('scene_info'), dict)
+                or row.get('instruction_type') != instruction_types[row['setting']]):
+            raise ValueError('Invalid episode identity')
+        if 'scene_sequence_index' in row and (type(row['scene_sequence_index']) is not int
+                                               or not 0 <= row['scene_sequence_index'] < 10):
+            raise ValueError('Invalid explicit scene sequence index')
+        key = (row['task'], row['setting'], row['index'])
+        if key in expected:
+            raise ValueError('Duplicate episode identity')
+        expected[key] = row
+    cells = Counter((r['task'], r['setting']) for r in rows)
+    tasks = {r['task'] for r in rows}
+    if (len(rows) != count or len(tasks) != task_count
+            or set(cells) != {(task, setting) for task in tasks for setting in settings}
+            or set(cells.values()) != {quota}
+            or len({r['seed'] for r in rows}) != count):
+        raise ValueError('Episode task/setting quotas or unique seeds do not match protocol')
+    names = {f'seed_manifests/{task}__{setting}.json' for task, setting in cells}
+    if names != {name for name in files if name.startswith('seed_manifests/')}:
+        raise ValueError('Seed manifest cell inventory does not match protocol')
+    plan = []
+    for name in sorted(names):
+        manifest = _read(files[name])
+        episodes = manifest.get('episodes', [])
+        if manifest.get('status') != 'ready' or len(episodes) != quota:
+            raise ValueError('Cell manifest must be ready with the declared quota: ' + name)
+        seen = set()
+        for row in episodes:
+            key = (row['task'], row['setting'], row['index'])
+            if (key in seen or expected.get(key) != row
+                    or name != f"seed_manifests/{row['task']}__{row['setting']}.json"
+                    or (manifest.get('task'), manifest.get('setting')) != key[:2]):
+                raise ValueError('Episode and seed manifest identities differ: ' + name)
+            if row.get('instruction_type') != manifest.get('instruction_type'):
+                raise ValueError('Episode and manifest instruction types differ: ' + name)
+            seen.add(key)
+            plan.append({**row, 'manifest_sha256': checksums[name]})
+    commit = _published_commit(root, files) if require_published else None
+    return FrozenSubset(root, protocol,
+                        sorted(plan, key=lambda r: (r['index'], r['task'], r['setting'])),
+                        commit, sha256(files['SHA256SUMS']), checksums['protocol.json'])

scripts/hybrid_capacity_telemetry.py

@@ -0,0 +1,176 @@
+"""Local capacity telemetry: one NVML GPU and owned Linux process trees.
+
+CPU percentages use one logical CPU as 100%. RSS sums count shared pages once
+per process and are not unique physical memory. Host MemAvailable is separate.
+"""
+import ctypes
+import os
+from pathlib import Path
+import time
+
+from eval_common import MemoryInfo
+
+GIB = 1024 ** 3
+
+
+class Utilization(ctypes.Structure):
+    _fields_ = [('gpu', ctypes.c_uint), ('memory', ctypes.c_uint)]
+
+
+def read_process(pid, proc_root=Path('/proc')):
+    """PID plus start ticks is the identity; comm can contain spaces/parens."""
+    try:
+        text = (Path(proc_root) / str(pid) / 'stat').read_text()
+        suffix = text[text.rfind(')') + 2:].split()
+        return {'pid': int(pid), 'start_ticks': int(suffix[19]),
+                'ppid': int(suffix[1]), 'pgrp': int(suffix[2]), 'session': int(suffix[3]),
+                'state': suffix[0], 'cpu_ticks': int(suffix[11]) + int(suffix[12]),
+                'rss_bytes': max(0, int(suffix[21])) * os.sysconf('SC_PAGE_SIZE')}
+    except (OSError, ValueError, IndexError):
+        return None
+
+
+def process_snapshot(proc_root=Path('/proc')):
+    records = {}
+    for path in Path(proc_root).iterdir():
+        if path.name.isdigit():
+            row = read_process(int(path.name), proc_root)
+            if row is not None:
+                records[row['pid']] = row
+    return records
+
+
+def identity(row):
+    return row['pid'], row['start_ticks']
+
+
+def owned_processes(snapshot, roots, remembered=()):
+    """Follow parent links only from matching identities; retain observed orphans."""
+    known = set(roots) | set(remembered)
+    selected = {pid for pid, row in snapshot.items() if identity(row) in known}
+    while True:
+        extra = {pid for pid, row in snapshot.items() if row['ppid'] in selected}
+        if extra <= selected:
+            break
+        selected |= extra
+    return [snapshot[pid] for pid in sorted(selected)]
+
+
+class NvmlGpu:
+    def __init__(self, uuid):
+        if not uuid or not uuid.startswith('GPU-') or any(x.isspace() for x in uuid) or ',' in uuid:
+            raise ValueError('Select one physical GPU UUID explicitly')
+        self.uuid = uuid
+        self.lib = ctypes.CDLL('libnvidia-ml.so.1')
+        self.check(self.lib.nvmlInit_v2())
+        self.handle = ctypes.c_void_p()
+        self.check(self.lib.nvmlDeviceGetHandleByUUID(uuid.encode(), ctypes.byref(self.handle)))
+        actual = ctypes.create_string_buffer(96)
+        self.check(self.lib.nvmlDeviceGetUUID(self.handle, actual, len(actual)))
+        if actual.value.decode() != uuid:
+            raise RuntimeError('NVML GPU UUID mismatch')
+
+    @staticmethod
+    def check(code):
+        if code:
+            raise RuntimeError('NVML error ' + str(code))
+
+    def sample(self):
+        memory, utilization, power = MemoryInfo(), Utilization(), ctypes.c_uint()
+        self.check(self.lib.nvmlDeviceGetMemoryInfo(self.handle, ctypes.byref(memory)))
+        utilization_code = self.lib.nvmlDeviceGetUtilizationRates(self.handle, ctypes.byref(utilization))
+        power_code = self.lib.nvmlDeviceGetPowerUsage(self.handle, ctypes.byref(power))
+        return {'gpu_uuid': self.uuid, 'memory_used_bytes': memory.used,
+                'memory_total_bytes': memory.total,
+                'utilization_percent': utilization.gpu if utilization_code == 0 else None,
+                'power_watts': power.value / 1000 if power_code == 0 else None,
+                'optional_metric_errors': {'utilization': utilization_code, 'power': power_code}}
+
+    def close(self):
+        self.lib.nvmlShutdown()
+
+
+class CapacityTelemetry:
+    def __init__(self, gpu_uuid, gpu_reader=None, proc_root=Path('/proc')):
+        self.gpu = gpu_reader if gpu_reader is not None else NvmlGpu(gpu_uuid)
+        self.proc_root = Path(proc_root)
+        self.previous = {}
+        self.previous_time = None
+        self.remembered = set()
+        self.ticks_per_second = os.sysconf('SC_CLK_TCK')
+
+    def sample(self, roots):
+        now = time.monotonic()
+        snapshot = process_snapshot(self.proc_root)
+        rows = owned_processes(snapshot, roots, self.remembered)
+        self.remembered = {identity(row) for row in rows}
+        elapsed = None if self.previous_time is None else now - self.previous_time
+        for row in rows:
+            previous = self.previous.get(identity(row))
+            row['cpu_percent'] = (100 * (row['cpu_ticks'] - previous) / self.ticks_per_second / elapsed
+                                  if previous is not None and elapsed and elapsed > 0 else None)
+        self.previous = {identity(row): row['cpu_ticks'] for row in rows}
+        self.previous_time = now
+        meminfo = {}
+        for line in (self.proc_root / 'meminfo').read_text().splitlines():
+            key, value = line.split(':', 1)
+            if key in ('MemTotal', 'MemAvailable', 'SwapTotal', 'SwapFree'):
+                meminfo[key + '_bytes'] = int(value.split()[0]) * 1024
+        if 'MemAvailable_bytes' not in meminfo:
+            raise RuntimeError('Host MemAvailable is unavailable')
+        return {'monotonic': now, 'timestamp': time.time(), 'gpu': self.gpu.sample(),
+                'host': meminfo, 'processes': rows,
+                'process_tree_rss_bytes': sum(row['rss_bytes'] for row in rows),
+                'process_tree_cpu_percent': sum(row['cpu_percent'] or 0 for row in rows),
+                'cpu_sample_has_baseline': elapsed is not None,
+                'rss_scope': 'Sum of RSS; shared pages can be counted repeatedly across processes.',
+                'gpu_scope': 'Whole selected physical GPU, including unrelated existing workloads.'}
+
+    def close(self):
+        self.gpu.close()
+
+
+def summarize_samples(rows, start, end, interval=1.0):
+    scoped = [row for row in rows if start <= row['monotonic'] <= end]
+    valid = [row for row in scoped if row.get('status') == 'ok']
+    covered = integral = 0.0
+    metrics = {'gpu_utilization_percent': ('gpu', 'utilization_percent'),
+               'gpu_power_watts': ('gpu', 'power_watts'),
+               'process_tree_cpu_percent': (None, 'process_tree_cpu_percent')}
+    totals = {name: [0.0, 0.0] for name in metrics}
+    def value(row, name):
+        parent, key = metrics[name]
+        if parent is None:
+            return row.get(key) if row.get('cpu_sample_has_baseline') else None
+        return row[parent].get(key)
+    for left, right in zip(scoped, scoped[1:]):
+        delta = right['monotonic'] - left['monotonic']
+        if left.get('status') == right.get('status') == 'ok' and 0 < delta <= 2.5 * interval:
+            integral += delta * (left['gpu']['memory_used_bytes'] + right['gpu']['memory_used_bytes']) / 2
+            covered += delta
+            for name in metrics:
+                a, b = value(left, name), value(right, name)
+                # CPU percentage is itself a rate over the preceding interval.
+                if name == 'process_tree_cpu_percent' and b is not None:
+                    totals[name][0] += delta * b
+                    totals[name][1] += delta
+                elif a is not None and b is not None:
+                    totals[name][0] += delta * (a + b) / 2
+                    totals[name][1] += delta
+    span = end - start
+    summary = {'samples': len(valid), 'failed_samples': len(scoped) - len(valid),
+            'gpu_mean_memory_bytes': integral / covered if covered else None,
+            'gpu_peak_memory_bytes': max((r['gpu']['memory_used_bytes'] for r in valid), default=None),
+            'process_tree_peak_rss_bytes': max((r['process_tree_rss_bytes'] for r in valid), default=None),
+            'host_min_available_bytes': min((r['host']['MemAvailable_bytes'] for r in valid), default=None),
+            'covered_seconds': covered, 'coverage': covered / span if span > 0 else 0,
+            'scope': 'One-second samples over the whole condition, not sums of overlapping episode GPU-hours.',
+            'rss_note': 'Shared RSS can be counted in multiple processes; host available memory is independent.',
+            'cpu_note': 'One logical CPU is 100%; first samples without a baseline are excluded. Process creation/exit between samples can omit CPU work; this is not exact cumulative CPU time.',
+            'peak_note': 'Sampled peak only; gaps over 2.5 sample intervals are excluded from the mean.'}
+    for name, (total, duration) in totals.items():
+        observed = [value(row, name) for row in valid if value(row, name) is not None]
+        summary['mean_' + name] = total / duration if duration else None
+        summary['peak_' + name] = max(observed, default=None)
+        summary[name + '_covered_seconds'] = duration
+    return summary

scripts/hybrid_concurrent_server.py

@@ -0,0 +1,341 @@
+"""Isolated hybrid_v1 sessions sharing one serial, FIFO inference executor.
+
+The unchanged loader's instance-level controlled_infer closes over its original
+policy. We deliberately rebind the class method for each independent wrapper,
+then reproduce that control context. Merely shallow-copying the wrapper would
+silently execute every session on the original object.
+"""
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import copy
+import hashlib
+import os
+from pathlib import Path
+import random
+import threading
+import time
+import uuid
+
+import numpy as np
+
+from hybrid_transport import (HybridPolicyServer, InfrastructureError, Packer,
+                              PROTOCOL, ProtocolSession, append_record,
+                              infer_with_noise, unpackb)
+
+CONCURRENCY_PROTOCOL = 'hybrid_concurrency_v1'
+GEOMETRY_FIELDS = ('pos_embeds', 'position_embeddings', 'cu_seqlens',
+                   'visual_split_sizes', 'visual_max_seqlen')
+
+
+def infer_fixed_robotwin(policy, observation, noise):
+    """Retain the frozen single-observation geometry used by offline warmup."""
+    if not observation.get('reset'):
+        if 'batch' in observation:
+            raise InfrastructureError('Concurrent service does not support dynamic batching')
+        for name in ('cam_high', 'cam_left_wrist', 'cam_right_wrist'):
+            value = observation.get('observation.images.' + name)
+            if (not isinstance(value, np.ndarray) or value.dtype != np.uint8 or
+                    value.shape != (240, 320, 3)):
+                raise InfrastructureError('Expected three raw uint8 240x320 RGB images')
+    return infer_with_noise(policy, observation, noise)
+
+
+class SessionRNG:
+    """Global generators are switched only by the dedicated inference thread."""
+    def __init__(self, torch_module=None):
+        self.torch = torch_module
+
+    def capture(self):
+        state = {'python': random.getstate(), 'numpy': np.random.get_state(),
+                 'hash_seed': os.environ.get('PYTHONHASHSEED')}
+        if self.torch is not None:
+            state['torch'] = self.torch.get_rng_state().clone()
+            state['cuda'] = [x.clone() for x in self.torch.cuda.get_rng_state_all()]
+        return state
+
+    def restore(self, state):
+        random.setstate(state['python'])
+        np.random.set_state(state['numpy'])
+        if state['hash_seed'] is None:
+            os.environ.pop('PYTHONHASHSEED', None)
+        else:
+            os.environ['PYTHONHASHSEED'] = state['hash_seed']
+        if self.torch is not None:
+            self.torch.set_rng_state(state['torch'])
+            self.torch.cuda.set_rng_state_all(state['cuda'])
+
+
+def clone_official_policy(original, torch_module=None):
+    """Independent wrapper/transform/tokenizer state, shared parameter tensors.
+
+    This audited adapter supports the frozen RoboTwin policy, batch=1, chunk_ret
+    and no compilation. All copies and inference execute on the same thread.
+    The neural model is shared; its per-call KV cache is local in sample_actions.
+    The small persistent visual-geometry cache is separately switched below.
+    """
+    if torch_module is None:
+        import torch as torch_module
+    if not original.chunk_ret or original.use_compile:
+        raise InfrastructureError('Concurrency requires chunk_ret=True and compile=False')
+    replica = copy.copy(original)
+    shared = {'vla', 'sample_actions_fn', 'infer'}
+    cleared = {'last_action_chunk', 'last_normalized_action_chunk'}
+    for name, value in vars(original).items():
+        if name in cleared:
+            setattr(replica, name, None)
+        elif name not in shared:
+            setattr(replica, name, copy.deepcopy(value))
+    replica.global_step = 0
+    # nn.Module shallow copies otherwise share these registration containers.
+    replica.vla = copy.copy(original.vla)
+    for name in ('_modules', '_buffers', '_parameters'):
+        if hasattr(original.vla, name):
+            setattr(replica.vla, name, dict(getattr(original.vla, name)))
+    if hasattr(replica.vla, '_modules'):
+        replica.vla._modules.pop('feature_transform', None)
+    replica.vla.__dict__.pop('feature_transform', None)
+    replica.vla.feature_transform = None
+    # Keep the copied processor and tokenizer coherent; both are CPU objects.
+    if hasattr(replica, 'processor'):
+        replica.language_tokenizer = replica.processor.tokenizer
+    if hasattr(replica.vla, 'config'):
+        replica.vla.config = replica.config
+    raw_infer = type(original).infer.__get__(replica, type(replica))
+
+    def controlled_infer(observation):
+        if observation.get('reset'):
+            from deploy.lingbot_vla_v2_policy import set_seed_everywhere
+            set_seed_everywhere(int(observation.get('policy_seed', 42)))
+        with torch_module.inference_mode(), torch_module.autocast('cuda', enabled=False):
+            return raw_infer(observation)
+
+    replica.infer = controlled_infer
+    return replica
+
+
+class IsolatedSession:
+    def __init__(self, original, noise_shape, synchronize, policy_factory,
+                 infer_adapter, rng):
+        self.original = original
+        self.synchronize = synchronize
+        self.policy_factory = policy_factory
+        self.infer_adapter = infer_adapter
+        self.rng = rng
+        self.rng_state = None
+        self.policy = None
+        self.geometry = None
+        self.protocol = ProtocolSession(self.infer, noise_shape, synchronize)
+        self.closed = threading.Event()
+        self.connection_id = uuid.uuid4().hex
+
+    def infer(self, observation, noise):
+        return self.infer_adapter(self.policy, observation, noise)
+
+    def process(self, request, digest, enqueued_at, fifo_index, pending):
+        started = time.perf_counter()
+        if self.closed.is_set():
+            raise InfrastructureError('Connection closed before queued request execution')
+        queue_ms = (started - enqueued_at) * 1000
+        init_ms = 0.0
+        if self.policy is None:
+            init_started = time.perf_counter()
+            self.policy = self.policy_factory(self.original)
+            init_ms = (time.perf_counter() - init_started) * 1000
+        switch_started = time.perf_counter()
+        ambient_rng = self.rng.capture()
+        if self.rng_state is not None:
+            self.rng.restore(self.rng_state)
+        # Precompute geometry is not episode history. Still save/restore it so
+        # a reset or later cache allocation cannot affect another connection.
+        model = getattr(getattr(self.policy, 'vla', None), 'model', None)
+        geometry_owner = getattr(model, 'qwenvl_with_expert', None)
+        original_geometry = None
+        if geometry_owner is not None:
+            original_geometry = {key: getattr(geometry_owner, key)
+                                 for key in GEOMETRY_FIELDS}
+            if self.geometry is None:
+                self.geometry = dict(original_geometry)
+            for key, value in self.geometry.items():
+                setattr(geometry_owner, key, value)
+        switch_ms = (time.perf_counter() - switch_started) * 1000
+        try:
+            # ProtocolSession performs identity/noise validation and measures
+            # CUDA-synchronized inference, excluding queue and state switching.
+            response, duplicate = self.protocol.process(request, digest)
+        finally:
+            switch_started = time.perf_counter()
+            self.rng_state = self.rng.capture()
+            self.rng.restore(ambient_rng)
+            if geometry_owner is not None:
+                self.geometry = {key: getattr(geometry_owner, key)
+                                 for key in GEOMETRY_FIELDS}
+                for key, value in original_geometry.items():
+                    setattr(geometry_owner, key, value)
+            switch_ms += (time.perf_counter() - switch_started) * 1000
+        # Preserve cached actions, while reporting the actual cost of this
+        # delivery. A duplicate never executes infer or advances RNG/state.
+        response = dict(response)
+        if duplicate:
+            response['server_cached_infer_ms'] = response['server_infer_ms']
+            response['server_infer_ms'] = 0.0
+        response.update(concurrency_protocol=CONCURRENCY_PROTOCOL,
+                        server_queue_ms=queue_ms,
+                        server_state_switch_ms=switch_ms,
+                        server_session_init_ms=init_ms,
+                        server_fifo_index=fifo_index,
+                        server_pending_at_enqueue=pending,
+                        server_execution_thread_id=threading.get_ident(),
+                        duplicate=duplicate)
+        return response, duplicate
+
+    def release(self):
+        self.closed.set()
+        if self.policy is not None:
+            # Break controlled_infer -> bound method -> replica cycles now,
+            # without waiting for GC to reclaim large CPU tokenizer copies.
+            self.policy.__dict__.pop('infer', None)
+            self.policy.last_action_chunk = None
+            self.policy.last_normalized_action_chunk = None
+            self.policy.vla.feature_transform = None
+        self.policy = self.geometry = self.rng_state = None
+        self.protocol.cache.clear()
+        self.protocol.seen_sessions.clear()
+        self.protocol.infer = None
+
+
+class ConcurrentHybridPolicyServer(HybridPolicyServer):
+    def __init__(self, *args, max_clients=4, policy_factory=None,
+                 infer_adapter=None, rng=None, **kwargs):
+        if type(max_clients) is not int or not 1 <= max_clients <= 8:
+            raise ValueError('max_clients must be an integer between 1 and 8')
+        super().__init__(*args, **kwargs)
+        if self.log_path is not None:
+            self.log_path = Path(self.log_path).resolve()
+        self.max_clients = max_clients
+        self.policy_factory = policy_factory or clone_official_policy
+        self.infer_adapter = infer_adapter or infer_fixed_robotwin
+        if rng is None:
+            import torch
+            rng = SessionRNG(torch)
+        self.rng = rng
+        self.executor = ThreadPoolExecutor(max_workers=1,
+                                           thread_name_prefix='hybrid-policy-fifo')
+        self.connections = set()
+        self._fifo = self._pending = 0
+        self.metadata.update(
+            concurrency_protocol=CONCURRENCY_PROTOCOL,
+            max_clients=max_clients,
+            scheduler='FIFO_single_inference_thread_no_batching',
+            session_isolation='independent_policy_vla_facade_processor_transform_chunks_and_RNG',
+            shared_weights=True, model_replicas=1,
+            geometry_cache='session_switched_fixed_3x240x320_RGB_batch1',
+            queue_timing='from_decoded_request_enqueue_to_executor_entry',
+            inference_timing='ProtocolSession_CUDA_synchronized_excludes_queue_and_state_switch',
+            duplicate_timing='cached_result_no_execution_server_infer_ms_zero')
+
+    async def run(self):
+        try:
+            await super().run()
+        finally:
+            self.executor.shutdown(wait=True, cancel_futures=True)
+
+    async def submit(self, session, request, digest):
+        if session.closed.is_set():
+            raise InfrastructureError('Connection is closed')
+        self._fifo += 1
+        self._pending += 1
+        enqueued_at = time.perf_counter()
+        future = asyncio.get_running_loop().run_in_executor(
+            self.executor, session.process, request, digest, enqueued_at,
+            self._fifo, self._pending)
+        try:
+            # Handler cancellation must not release session state while CUDA
+            # still uses it. Shield preserves completion of in-flight work.
+            return await asyncio.shield(future)
+        except asyncio.CancelledError:
+            session.closed.set()
+            # Multiple shutdown/cancellation signals still must not let a
+            # handler release its replica while the worker is using it.
+            while not future.done():
+                try:
+                    await asyncio.shield(future)
+                except asyncio.CancelledError:
+                    continue
+                except Exception:
+                    break
+            if not future.cancelled():
+                future.exception()  # consume a discarded worker exception
+            raise
+        finally:
+            self._pending -= 1
+
+    async def _handler(self, websocket):
+        from websockets.exceptions import ConnectionClosed
+        if len(self.connections) >= self.max_clients:
+            append_record(self.log_path, {'timestamp': time.time(),
+                          'event': 'client_limit_rejected', 'max_clients': self.max_clients})
+            await websocket.close(code=1013, reason='Concurrent policy client limit reached')
+            return
+        session = IsolatedSession(self.policy, self.noise_shape, self.synchronize,
+                                  self.policy_factory, self.infer_adapter, self.rng)
+        self.connections.add(session)
+        packer = Packer()
+        disconnected = asyncio.create_task(websocket.wait_closed())
+        # Flag queued work immediately on disconnect. In-flight GPU execution
+        # completes in the same worker; its response is then discarded.
+        disconnected.add_done_callback(lambda _: session.closed.set())
+        append_record(self.log_path, {'timestamp': time.time(), 'event': 'client_connected',
+                      'connection_id': session.connection_id,
+                      'active_clients': len(self.connections)})
+        try:
+            await websocket.send(packer.pack(self.metadata))
+            while True:
+                raw = await websocket.recv()
+                if not isinstance(raw, bytes):
+                    raise InfrastructureError('Expected a binary request')
+                started = time.perf_counter()
+                request = unpackb(raw)
+                unpack_ms = (time.perf_counter() - started) * 1000
+                digest = hashlib.sha256(raw).hexdigest()
+                response, duplicate = await self.submit(session, request, digest)
+                started = time.perf_counter()
+                payload = packer.pack(response)
+                pack_ms = (time.perf_counter() - started) * 1000
+                started = time.perf_counter()
+                if not session.closed.is_set():
+                    await websocket.send(payload)
+                send_ms = (time.perf_counter() - started) * 1000
+                append_record(self.log_path, {
+                    'timestamp': time.time(), 'connection_id': session.connection_id,
+                    'active_clients': len(self.connections),
+                    'session_id': response['session_id'],
+                    'episode_id': response['episode_id'], 'sequence_id': response['sequence_id'],
+                    'operation': request['operation'], 'duplicate': duplicate,
+                    'request_sha256': digest, 'noise_sha256': response['noise_sha256'],
+                    'request_bytes': len(raw), 'response_bytes': len(payload),
+                    'server_unpack_ms': unpack_ms, 'server_pack_ms': pack_ms,
+                    'server_send_ms': send_ms,
+                    **{key: value for key, value in response.items()
+                       if key.startswith('server_') or key == 'concurrency_protocol'},
+                    'response_discarded_after_disconnect': session.closed.is_set()})
+                if session.closed.is_set():
+                    break
+        except ConnectionClosed:
+            pass
+        except Exception as error:
+            append_record(self.log_path, {'timestamp': time.time(),
+                          'connection_id': session.connection_id,
+                          'event': 'infrastructure_error', 'error': str(error)})
+            try:
+                if not session.closed.is_set():
+                    await websocket.send(packer.pack({'protocol': PROTOCOL, 'error': str(error)}))
+                    await websocket.close(code=1011, reason='Episode invalidated')
+            except ConnectionClosed:
+                pass
+        finally:
+            disconnected.cancel()
+            session.release()
+            self.connections.discard(session)
+            append_record(self.log_path, {'timestamp': time.time(), 'event': 'client_disconnected',
+                          'connection_id': session.connection_id,
+                          'active_clients': len(self.connections)})

scripts/hybrid_transport.py

@@ -0,0 +1,378 @@
+"""Bounded, synchronous, uncompressed policy transport for hybrid evaluation.
+
+There is deliberately no reconnect/retry path: a lost connection invalidates the
+current rollout. Session/sequence checks protect against executing stale actions.
+"""
+import asyncio
+import hashlib
+import http
+import json
+import math
+from pathlib import Path
+import socket
+import sys
+import threading
+import time
+import uuid
+
+import numpy as np
+
+UPSTREAM = Path(__file__).resolve().parents[1] / 'third_party/lingbot-vla-v2'
+if str(UPSTREAM) not in sys.path:
+    sys.path.insert(0, str(UPSTREAM))
+from deploy.msgpack_numpy import Packer, unpackb
+
+PROTOCOL = 'hybrid_v1'
+
+
+class InfrastructureError(RuntimeError):
+    """Abort this episode; restarting requires restoring the complete scene."""
+
+
+def append_record(path, value):
+    if path is not None:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open('a') as stream:
+            stream.write(json.dumps(value, sort_keys=True) + '\n')
+            stream.flush()
+
+
+def noise_sha256(noise):
+    return hashlib.sha256(np.ascontiguousarray(noise).tobytes()).hexdigest()
+
+
+def generate_noise(policy_seed, sequence_id, shape):
+    """Canonical CPU float32 noise; this is an explicitly new RNG protocol."""
+    rng = np.random.Generator(np.random.PCG64(np.random.SeedSequence(
+        [int(policy_seed), int(sequence_id)])))
+    return rng.standard_normal(tuple(shape), dtype=np.float32)
+
+
+def validate_noise(noise, shape):
+    if not isinstance(noise, np.ndarray) or noise.dtype != np.float32:
+        raise InfrastructureError('Noise must be a CPU float32 NumPy array')
+    if tuple(noise.shape) != tuple(shape) or not np.isfinite(noise).all():
+        raise InfrastructureError('Invalid noise shape or nonfinite noise')
+    return np.ascontiguousarray(noise)
+
+
+def infer_with_noise(policy, observation, noise, torch_module=None):
+    """Inject noise through the upstream API without changing upstream files."""
+    if noise is None:
+        return policy.infer(observation)
+    if torch_module is None:
+        import torch as torch_module
+    original = policy.sample_actions_fn
+    calls = 0
+
+    def sample(*args, **kwargs):
+        nonlocal calls
+        calls += 1
+        if calls != 1 or kwargs.get('noise') is not None:
+            raise InfrastructureError('Expected exactly one upstream noise injection')
+        state = args[4] if len(args) > 4 else kwargs['state']
+        # Upstream updates x_t=noise in place. Clone even after device conversion.
+        tensor = torch_module.from_numpy(noise.copy()).to(
+            device=state.device, dtype=state.dtype).clone()
+        kwargs['noise'] = tensor
+        return original(*args, **kwargs)
+
+    policy.sample_actions_fn = sample
+    try:
+        result = policy.infer(observation)
+        if calls != 1:
+            raise InfrastructureError('The policy did not consume explicit noise')
+        return result
+    finally:
+        policy.sample_actions_fn = original
+
+
+class ProtocolSession:
+    """One connection owns one policy; completed request IDs are idempotent."""
+    def __init__(self, infer, noise_shape, synchronize=lambda: None):
+        self.infer = infer
+        self.noise_shape = tuple(noise_shape)
+        self.synchronize = synchronize
+        self.session_id = None
+        self.episode_id = None
+        self.sequence_id = -1
+        self.cache = {}
+        self.seen_sessions = set()
+
+    def process(self, request, digest):
+        if not isinstance(request, dict) or request.get('protocol') != PROTOCOL:
+            raise InfrastructureError('Unsupported hybrid protocol')
+        session = request.get('session_id')
+        episode = request.get('episode_id')
+        sequence = request.get('sequence_id')
+        if (not isinstance(session, str) or not 1 <= len(session) <= 128 or
+                not isinstance(episode, str) or not 1 <= len(episode) <= 256 or
+                type(sequence) is not int or sequence < 0):
+            raise InfrastructureError('Invalid request identity')
+        operation = request.get('operation')
+        if session == self.session_id and sequence in self.cache:
+            cached_hash, cached_response = self.cache[sequence]
+            if episode != self.episode_id or digest != cached_hash:
+                raise InfrastructureError('Reused sequence has different payload or episode')
+            return cached_response, True
+        if operation == 'reset':
+            seed = request.get('policy_seed')
+            if (sequence != 0 or session in self.seen_sessions or
+                    type(seed) is not int or not 0 <= seed < 2**32):
+                raise InfrastructureError('A new episode requires a new session and sequence zero')
+            observation = {'reset': True, 'robo_name': 'robotwin', 'policy_seed': seed}
+            noise = None
+        elif operation == 'infer':
+            if (session != self.session_id or episode != self.episode_id or
+                    sequence != self.sequence_id + 1):
+                raise InfrastructureError('Missing reset, stale session, or out-of-order request')
+            observation = request.get('observation')
+            if not isinstance(observation, dict) or observation.get('reset'):
+                raise InfrastructureError('Invalid inference observation')
+            noise = validate_noise(request.get('noise'), self.noise_shape)
+        else:
+            raise InfrastructureError('Unsupported operation')
+        self.synchronize()
+        started = time.perf_counter()
+        action = self.infer(observation, noise)
+        self.synchronize()
+        infer_ms = (time.perf_counter() - started) * 1000
+        if not isinstance(action, dict):
+            raise InfrastructureError('Policy returned an invalid response')
+        response = {'protocol': PROTOCOL, 'session_id': session,
+                    'episode_id': episode, 'sequence_id': sequence,
+                    'request_sha256': digest, 'result': action,
+                    'server_infer_ms': infer_ms,
+                    'noise_sha256': noise_sha256(noise) if noise is not None else None}
+        if operation == 'reset':
+            self.session_id, self.episode_id = session, episode
+            self.cache = {}
+            self.seen_sessions.add(session)
+        self.sequence_id = sequence
+        self.cache[sequence] = (digest, response)
+        return response, False
+
+
+class HybridPolicyServer:
+    def __init__(self, policy, host='127.0.0.1', port=None, metadata=None,
+                 log_path=None, synchronize=None, hardware=None):
+        if host != '127.0.0.1':
+            raise ValueError('Hybrid server must bind to loopback; use an SSH tunnel')
+        self.policy, self.host, self.port = policy, host, port
+        self.log_path = log_path
+        self.noise_shape = (1, policy.config.n_action_steps, policy.config.max_action_dim)
+        if synchronize is None:
+            import torch
+            synchronize = torch.cuda.synchronize
+            properties = torch.cuda.get_device_properties(torch.cuda.current_device())
+            hardware = {'gpu_name': properties.name,
+                        'gpu_memory_bytes': properties.total_memory,
+                        'gpu_capability': list(torch.cuda.get_device_capability()),
+                        'gpu_uuid': str(getattr(properties, 'uuid', 'unavailable')),
+                        'torch_version': torch.__version__, 'cuda_version': torch.version.cuda}
+        self.synchronize = synchronize
+        self.metadata = {**(metadata or {}), **(hardware or {}),
+                         'protocol': PROTOCOL, 'evaluation_protocol': PROTOCOL,
+                         'noise_shape': list(self.noise_shape),
+                         'noise_protocol': 'numpy_PCG64_SeedSequence_policy_seed_sequence_float32',
+                         'transport_compression': None, 'reconnect_policy': 'abort_episode'}
+        self._active = False
+
+    def serve_forever(self):
+        asyncio.run(self.run())
+
+    async def run(self):
+        from websockets.asyncio.server import serve
+        async with serve(self._handler, self.host, self.port, compression=None,
+                         max_size=None, ping_interval=None, process_request=self._health_check) as server:
+            await server.serve_forever()
+
+    @staticmethod
+    def _health_check(connection, request):
+        if request.path == '/healthz':
+            return connection.respond(http.HTTPStatus.OK, 'OK\n')
+
+    async def _handler(self, websocket):
+        from websockets.exceptions import ConnectionClosed
+        packer = Packer()
+        if self._active:
+            await websocket.close(code=1013, reason='A policy client already owns this server')
+            return
+        self._active = True
+        session = ProtocolSession(
+            lambda observation, noise: infer_with_noise(self.policy, observation, noise),
+            self.noise_shape, self.synchronize)
+        try:
+            await websocket.send(packer.pack(self.metadata))
+            while True:
+                raw = await websocket.recv()
+                if not isinstance(raw, bytes):
+                    raise InfrastructureError('Expected a binary request')
+                started = time.perf_counter()
+                request = unpackb(raw)
+                unpack_ms = (time.perf_counter() - started) * 1000
+                digest = hashlib.sha256(raw).hexdigest()
+                response, duplicate = session.process(request, digest)
+                started = time.perf_counter()
+                payload = packer.pack(response)
+                pack_ms = (time.perf_counter() - started) * 1000
+                started = time.perf_counter()
+                await websocket.send(payload)
+                send_ms = (time.perf_counter() - started) * 1000
+                append_record(self.log_path, {
+                    'timestamp': time.time(), 'session_id': response['session_id'],
+                    'episode_id': response['episode_id'], 'sequence_id': response['sequence_id'],
+                    'operation': request['operation'], 'duplicate': duplicate,
+                    'request_sha256': digest, 'noise_sha256': response['noise_sha256'],
+                    'request_bytes': len(raw), 'response_bytes': len(payload),
+                    'server_unpack_ms': unpack_ms, 'server_pack_ms': pack_ms,
+                    'server_send_ms': send_ms, 'server_infer_ms': response['server_infer_ms']})
+        except ConnectionClosed:
+            pass
+        except Exception as error:
+            append_record(self.log_path, {'timestamp': time.time(),
+                          'event': 'infrastructure_error', 'error': str(error)})
+            try:
+                await websocket.send(packer.pack({'protocol': PROTOCOL, 'error': str(error)}))
+                await websocket.close(code=1011, reason='Episode invalidated')
+            except ConnectionClosed:
+                pass
+        finally:
+            self._active = False
+
+
+class HybridClient:
+    def __init__(self, host='127.0.0.1', port=9340, timeout=120,
+                 log_path=None, _connection=None):
+        if not 0 < timeout <= 120:
+            raise ValueError('timeout must be in (0,120] seconds')
+        from websockets.sync.client import connect
+        self.timeout, self.log_path = timeout, log_path
+        self._packer = Packer()
+        self._ws = None
+        self._broken = False
+        self._session_id = self._episode_id = None
+        self._sequence = 0
+        self._seed = None
+        self.metrics, self.last_metrics = [], None
+        try:
+            self._ws = _connection or connect(
+                f'ws://{host}:{port}', compression=None, max_size=None,
+                open_timeout=timeout, close_timeout=2, ping_interval=None)
+            metadata = unpackb(self._ws.recv(timeout=timeout))
+            if metadata.get('protocol') != PROTOCOL:
+                raise InfrastructureError('Unexpected server protocol')
+            shape = metadata.get('noise_shape')
+            if not isinstance(shape, list) or len(shape) != 3 or any(type(x) is not int or x <= 0 for x in shape):
+                raise InfrastructureError('Invalid server noise shape')
+            self._metadata = metadata
+        except Exception as error:
+            self.close()
+            raise InfrastructureError(f'Policy connection failed: {error}') from error
+
+    def get_server_metadata(self):
+        return dict(self._metadata)
+
+    def reset(self, episode_id, policy_seed):
+        if self._broken:
+            raise InfrastructureError('Connection invalidated; restore scene and create a new client')
+        self._session_id = uuid.uuid4().hex
+        self._episode_id = str(episode_id)
+        self._sequence, self._seed = 0, int(policy_seed)
+        return self._request('reset', policy_seed=self._seed)
+
+    def infer(self, observation, noise=None):
+        if self._session_id is None:
+            raise InfrastructureError('reset() is required before inference')
+        sequence = self._sequence + 1
+        if noise is None:
+            noise = generate_noise(self._seed, sequence, self._metadata['noise_shape'])
+        noise = validate_noise(noise, self._metadata['noise_shape'])
+        self._sequence = sequence
+        return self._request('infer', observation=observation, noise=noise)
+
+    def _request(self, operation, **values):
+        if self._broken or self._ws is None:
+            raise InfrastructureError('Connection invalidated; no automatic retry is permitted')
+        request = {'protocol': PROTOCOL, 'session_id': self._session_id,
+                   'episode_id': self._episode_id, 'sequence_id': self._sequence,
+                   'operation': operation, **values}
+        started = time.perf_counter()
+        raw = self._packer.pack(request)
+        pack_ms = (time.perf_counter() - started) * 1000
+        digest = hashlib.sha256(raw).hexdigest()
+        started = time.perf_counter()
+        # recv(timeout=...) alone cannot bound a blocked socket.sendall().
+        # Closing the underlying socket from a timer bounds both phases.
+        def abort_socket():
+            connection_socket = getattr(self._ws, 'socket', None)
+            if connection_socket is not None:
+                try:
+                    connection_socket.shutdown(socket.SHUT_RDWR)
+                except OSError:
+                    pass
+                connection_socket.close()
+        watchdog = threading.Timer(self.timeout, abort_socket)
+        watchdog.daemon = True
+        watchdog.start()
+        try:
+            self._ws.send(raw)
+            remaining = self.timeout - (time.perf_counter() - started)
+            if remaining <= 0:
+                raise TimeoutError('Policy request deadline expired during send')
+            response_raw = self._ws.recv(timeout=remaining)
+            rtt_ms = (time.perf_counter() - started) * 1000
+            if not isinstance(response_raw, bytes):
+                raise InfrastructureError('Expected a binary response')
+            started = time.perf_counter()
+            response = unpackb(response_raw)
+            unpack_ms = (time.perf_counter() - started) * 1000
+            if response.get('error'):
+                raise InfrastructureError(response['error'])
+            for key in ('protocol', 'session_id', 'episode_id', 'sequence_id'):
+                if response.get(key) != request[key]:
+                    raise InfrastructureError(f'Response identity mismatch: {key}')
+            if response.get('request_sha256') != digest:
+                raise InfrastructureError('Response request hash mismatch')
+            noise_hash = noise_sha256(values['noise']) if 'noise' in values else None
+            if response.get('noise_sha256') != noise_hash:
+                raise InfrastructureError('Response noise hash mismatch')
+            if not isinstance(response.get('result'), dict):
+                raise InfrastructureError('Invalid policy result')
+            for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms'):
+                if key in response and (type(response[key]) not in (int, float) or
+                                        not math.isfinite(response[key]) or response[key] < 0):
+                    raise InfrastructureError('Invalid server timing: ' + key)
+        except Exception as error:
+            self._broken = True
+            self.close()
+            raise InfrastructureError(f'Policy request failed; episode must restart: {error}') from error
+        finally:
+            watchdog.cancel()
+        metric = {'timestamp': time.time(), 'session_id': self._session_id,
+                  'episode_id': self._episode_id, 'sequence_id': self._sequence,
+                  'operation': operation, 'request_sha256': digest,
+                  'noise_sha256': noise_hash, 'client_pack_ms': pack_ms,
+                  'client_rtt_ms': rtt_ms, 'client_unpack_ms': unpack_ms,
+                  'request_bytes': len(raw), 'response_bytes': len(response_raw),
+                  'server_infer_ms': response['server_infer_ms']}
+        for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms',
+                    'server_fifo_index', 'server_pending_at_enqueue', 'concurrency_protocol'):
+            if key in response:
+                metric[key] = response[key]
+        self.last_metrics = metric
+        self.metrics.append(metric)
+        append_record(self.log_path, metric)
+        return response['result']
+
+    def close(self):
+        if self._ws is not None:
+            try:
+                self._ws.close()
+            except Exception:
+                pass
+            self._ws = None
+
+
+HybridClientPolicy = HybridClient

scripts/hybrid_worker.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""A bounded RT episode for hybrid_v1; never writes the original v1 results."""
+import argparse
+import faulthandler
+import hashlib
+import importlib
+import json
+import os
+from pathlib import Path
+import pickle
+import random
+import re
+import signal
+import sys
+import time
+import traceback
+
+from eval_common import ROOT, Telemetry, save_json
+from eval_model_registry import MODEL_NAMES, validate_server_identity, validate_lora_identity
+from eval_planner_optimization import evaluation_planner_setup
+from eval_official_worker import (ROBOTWIN, LINGBOT, config, observation,
+                                 restore_scene_sequence, restore_task_state,
+                                 release_unused_cuda_cache)
+
+
+def scene_hash(env):
+    """Check exposed physical state and action counter around a blocking RPC."""
+    value = (env.take_action_cnt, env.robot.get_left_arm_jointState(),
+             env.robot.get_right_arm_jointState(),
+             env.robot.left_entity.get_qpos().tolist(), env.robot.left_entity.get_qvel().tolist(),
+             env.robot.right_entity.get_qpos().tolist(), env.robot.right_entity.get_qvel().tolist(),
+             [(a.get_name(), a.get_pose().p.tolist(), a.get_pose().q.tolist())
+              for a in env.scene.get_all_actors()])
+    return hashlib.sha256(pickle.dumps(value)).hexdigest()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--mode', choices=['capture', 'evaluate'], required=True)
+    parser.add_argument('--task', default='adjust_bottle')
+    parser.add_argument('--setting', choices=['clean', 'randomized'], required=True)
+    parser.add_argument('--index', type=int, default=0)
+    parser.add_argument('--condition', choices=['local', 'ssh_loopback', 'a100'], default='local')
+    parser.add_argument('--model', choices=MODEL_NAMES, default='robotwin')
+    parser.add_argument('--precision', choices=['bf16', 'fp32'], default='bf16')
+    parser.add_argument('--planner-initialization', choices=['skip_unused', 'legacy'],
+                        default='skip_unused',
+                        help='Skip unused expert GPU planners; legacy retains original setup for comparisons')
+    parser.add_argument('--evaluation-protocol', default='hybrid_v1_rt')
+    parser.add_argument('--subset-id', default='')
+    parser.add_argument('--subset-commit', default='')
+    parser.add_argument('--manifest-dir', type=Path, default=ROOT / 'manifests/official_eval_1000')
+    parser.add_argument('--port', type=int, default=19530)
+    parser.add_argument('--output', type=Path, required=True)
+    args = parser.parse_args()
+    if not re.fullmatch(r'hybrid_[a-z0-9_]+_rt', args.evaluation_protocol):
+        parser.error('Expected a named hybrid RT evaluation protocol')
+    if bool(args.subset_id) != bool(args.subset_commit) or (args.subset_commit and
+            not re.fullmatch('[0-9a-f]{40}', args.subset_commit)):
+        parser.error('A frozen subset requires both its subset ID and full Git commit')
+    args.output = args.output.resolve()
+    args.output.mkdir(parents=True, exist_ok=True)
+    if (args.output / 'result.json').exists():
+        raise RuntimeError('Choose a new output directory; completed results are immutable')
+    faulthandler.register(signal.SIGUSR1, all_threads=True)
+    save_json(args.output / 'diagnostics_ready.json', {'pid': os.getpid(), 'signal': 'SIGUSR1'})
+    if os.environ.get('EVAL_RENDER_SHADER', 'rt') != 'rt':
+        raise RuntimeError('Hybrid evaluation requires the original local RT rendering')
+    manifest_path = args.manifest_dir / f'{args.task}__{args.setting}.json'
+    manifest = json.loads(manifest_path.read_text())
+    row = next(r for r in manifest['episodes'] if r['index'] == args.index)
+    if manifest['status'] != 'ready':
+        raise RuntimeError('Manifest is not ready')
+    env = client = telemetry = None
+    def timeout(*_):
+        raise TimeoutError('Hybrid episode exceeded its wall-time deadline')
+    signal.signal(signal.SIGALRM, timeout)
+    # The eager LoRA service is slower and six sessions share its serial GPU.
+    # Keep exactly the same environment action limits and frozen episode seeds.
+    signal.alarm(2400 if args.model == 'lora8' else 1200)
+    try:
+        import numpy as np
+        os.chdir(ROBOTWIN)
+        sys.path[:0] = [str(ROBOTWIN), str(ROBOTWIN / 'description/utils'), str(LINGBOT)]
+        from eval_device import bind_sapien
+        bind_sapien()
+        cls = getattr(importlib.import_module('envs.' + args.task), args.task)
+        env = cls()
+        cfg = config(args.task, args.setting)
+        telemetry = Telemetry(args.output / 'gpu_samples.jsonl')
+        start = telemetry.sample()['monotonic']
+        random.seed(row['seed'])
+        scene_sequence = restore_scene_sequence(env, row)
+        with evaluation_planner_setup(cfg, mode=args.planner_initialization,
+                                      action_type='qpos', policy_execution='remote') as planner_setup:
+            env.setup_demo(now_ep_num=row['index'], seed=row['seed'], is_test=True, **cfg)
+            planner_setup.verify_environment(env)
+        restored_state = restore_task_state(env, row)
+        release_unused_cuda_cache(env)
+        env.set_instruction(instruction=row['instruction'])
+        setup_seconds = time.monotonic() - start
+        import sapien
+        shader_getter = getattr(sapien.render, 'get_camera_shader_dir', None)
+        provenance = {**row, 'evaluation_protocol': args.evaluation_protocol,
+                      'planner_initialization': args.planner_initialization,
+                      'planner_setup': planner_setup.provenance(),
+                      'noise_protocol': 'numpy_PCG64_SeedSequence_policy_seed_sequence_float32',
+                      'condition': args.condition, 'model': args.model, 'precision': args.precision,
+                      'manifest_sha256': hashlib.sha256(manifest_path.read_bytes()).hexdigest(),
+                      'render_shader_requested': 'rt',
+                      'render_shader_actual': str(shader_getter()) if shader_getter else 'getter_unavailable',
+                      'render_device': str(env.scene.render_system.device),
+                      'local_gpu_uuid': os.environ.get('EVAL_GPU_UUID'),
+                      'restored_scene_sequence': scene_sequence, 'restored_task_state': restored_state,
+                      'memory_scope': 'whole local GPU, includes desktop and any colocated policy',
+                      'transport_route': ('local -> NSCC sshd -> local policy (double tunnel)' if
+                                          args.condition == 'ssh_loopback' else args.condition)}
+        if args.subset_id:
+            provenance.update(subset_id=args.subset_id, subset_commit=args.subset_commit)
+        save_json(args.output / 'provenance.json', provenance)
+        first_observation_start = time.monotonic()
+        first_obs = observation(env)
+        first_observation_seconds = time.monotonic() - first_observation_start
+        np.savez(args.output / 'initial_observation.npz', **first_obs)
+        obs_hashes = {key: hashlib.sha256(np.ascontiguousarray(value).tobytes()).hexdigest()
+                      for key, value in first_obs.items() if key != 'task'}
+        save_json(args.output / 'observation_hashes.json', obs_hashes)
+        if args.mode == 'capture':
+            end = telemetry.sample()['monotonic']
+            result = {**provenance, 'status': 'captured', 'setup_seconds': setup_seconds,
+                      'observation_hashes': obs_hashes, **telemetry.summary(start, end)}
+        else:
+            from hybrid_transport import HybridClient, InfrastructureError
+            client = HybridClient(port=args.port, timeout=120, log_path=args.output / 'requests.jsonl')
+            metadata = client.get_server_metadata()
+            if metadata['model'] != args.model or metadata['precision'] != args.precision:
+                raise InfrastructureError('Server model/precision mismatch')
+            if args.model == 'e5':
+                validate_server_identity(metadata, ROOT)
+            if args.model == 'lora8':
+                validate_lora_identity(metadata, ROOT)
+            if args.condition == 'a100' and 'A100' not in metadata.get('gpu_name', ''):
+                raise InfrastructureError('A100 condition requires an actual A100 policy device')
+            if (args.evaluation_protocol != 'hybrid_v1_rt' and
+                    metadata.get('concurrency_protocol') != 'hybrid_concurrency_v1'):
+                raise InfrastructureError('Capacity evaluation requires isolated concurrent server')
+            save_json(args.output / 'server_metadata.json', metadata)
+            client.reset(f'{args.task}/{args.setting}/{args.index}', row['policy_seed'])
+            from e5_rollout_history import RolloutCombinedHistory
+            episode_id = f'{args.task}/{args.setting}/{args.index}'
+            history = RolloutCombinedHistory(episode_id, args.output, session_id=client._session_id) if args.model == 'e5' else None
+            rollout_start = time.monotonic()
+            success, calls = False, 0
+            observation_seconds, action_seconds = first_observation_seconds, 0.0
+            unchanged_waits = 0
+            while env.take_action_cnt < env.step_lim and not success:
+                tick = time.monotonic()
+                obs = first_obs if calls == 0 else observation(env)
+                observation_seconds += time.monotonic() - tick
+                before = scene_hash(env)
+                if history is not None:
+                    obs = history.observe(obs, env.take_action_cnt, calls, session_id=client._session_id)
+                response = client.infer(obs)
+                if scene_hash(env) != before:
+                    raise InfrastructureError('Physical state advanced during a blocking policy request')
+                unchanged_waits += 1
+                actions = np.asarray(response['action'])
+                if actions.shape != (50, 14) or not np.isfinite(actions).all():
+                    raise InfrastructureError(f'Invalid action chunk: {actions.shape}')
+                np.save(args.output / f'actions_{calls:03d}.npy', actions)
+                calls += 1
+                tick = time.monotonic()
+                for action in actions:
+                    if env.take_action_cnt >= env.step_lim:
+                        break
+                    before_counter = env.take_action_cnt
+                    env.take_action(action)
+                    if history is not None:
+                        history.record_completed(np.asarray(action)[None], before_counter=before_counter,
+                            after_counter=env.take_action_cnt, episode_id=episode_id, session_id=client._session_id)
+                    if env.eval_success:
+                        success = True
+                        break
+                action_seconds += time.monotonic() - tick
+                print(json.dumps({'event': 'chunk', 'calls': calls, 'actions': env.take_action_cnt,
+                                  'success': success, 'rtt_ms': client.last_metrics['client_rtt_ms']}), flush=True)
+            rollout_seconds = time.monotonic() - rollout_start
+            action_count, step_limit = env.take_action_cnt, env.step_lim
+            env.close_env(clear_cache=((row['index'] + 1) % cfg['clear_cache_freq'] == 0))
+            end = telemetry.sample()['monotonic']
+            metrics = [m for m in client.metrics if m['operation'] == 'infer']
+            means = {f'mean_{key}': sum(m[key] for m in metrics) / len(metrics)
+                     for key in ('client_pack_ms', 'client_rtt_ms', 'client_unpack_ms',
+                                 'server_infer_ms', 'request_bytes', 'response_bytes')}
+            if args.evaluation_protocol != 'hybrid_v1_rt':
+                for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms'):
+                    means[f'mean_{key}'] = sum(m[key] for m in metrics) / len(metrics)
+                    means[f'p95_{key}'] = float(np.percentile([m[key] for m in metrics], 95))
+                means['p95_client_rtt_ms'] = float(np.percentile([m['client_rtt_ms'] for m in metrics], 95))
+            result = {**provenance, 'status': 'completed', 'success': success,
+                      'setup_seconds': setup_seconds, 'rollout_seconds': rollout_seconds,
+                      'episode_wall_seconds': end - start, 'actions': action_count, 'step_limit': step_limit,
+                      'policy_calls': calls, 'physical_state_unchanged_during_requests': unchanged_waits,
+                      'observation_seconds': observation_seconds, 'action_execution_seconds': action_seconds,
+                      'first_observation_seconds': first_observation_seconds,
+                      'rollout_timing_scope': 'after initial observation/save/reset; includes state checks and action saves',
+                      'observation_hashes': obs_hashes, **means, **telemetry.summary(start, end)}
+            result['mean_transport_serialization_residual_ms'] = (
+                means['mean_client_rtt_ms'] - means['mean_server_infer_ms'])
+            if result['memory_coverage'] < 0.98:
+                raise InfrastructureError('Insufficient GPU telemetry coverage')
+        save_json(args.output / 'result.json', result)
+        print(json.dumps({'event': 'finished', **result}), flush=True)
+    except BaseException as error:
+        save_json(args.output / 'infrastructure_error.json',
+                  {'status': 'infrastructure_error', 'type': type(error).__name__, 'message': str(error),
+                   'traceback': traceback.format_exc(), 'timestamp': time.time()})
+        raise
+    finally:
+        signal.alarm(0)
+        if client is not None:
+            client.close()
+        if telemetry is not None:
+            try:
+                telemetry.close()
+            except Exception as error:
+                save_json(args.output / 'telemetry_cleanup_error.json', {'message': str(error)})
+        try:
+            env.close_env()
+        except Exception:
+            pass
+        robot = getattr(env, 'robot', None)
+        for key in ('left_proc', 'right_proc'):
+            process = getattr(robot, key, None)
+            if process is not None and process.is_alive():
+                process.terminate()
+                process.join(timeout=5)
+                if process.is_alive():
+                    process.kill()
+                    process.join(timeout=5)
+
+
+if __name__ == '__main__':
+    main()

scripts/release_eval.py

@@ -0,0 +1,65 @@
+"""Portable entry to original inference/rollout code. Plans by default; --run executes."""
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+SUBSET_COMMIT = 'b5abe512dafd400736c6dca5905f2fd262dd9029'
+PUBLIC_SUBSET_COMMIT = '73277c2022be224d3afb195b503a3cff56ded46d'
+SUBSET_CHECKSUMS_SHA256 = 'a8a41f7c5162732cce287e77628840bf754f631825d3a6a343d51c648f932eb9'
+
+
+def command(args):
+    common = ['--model','e5','--precision','fp32','--port',str(args.port),
+              '--output',str(args.output.resolve())]
+    if args.mode == 'server':
+        return [sys.executable,str(ROOT/'scripts/serve_hybrid_concurrent_policy.py'),
+                *common,'--max-clients','6']
+    if args.subset is None or args.task is None or args.setting is None:
+        raise ValueError('Episode requires --subset, --task and --setting')
+    from frozen_eval_subset import load_subset
+    subset = load_subset(args.subset,require_published=True)
+    if (subset.commit not in (SUBSET_COMMIT,PUBLIC_SUBSET_COMMIT)
+            or subset.protocol['subset_id'] != 'robotwin-eval-subset-v2-seen-unseen'
+            or subset.checksums_sha256 != SUBSET_CHECKSUMS_SHA256):
+        raise ValueError('Use the fixed original benchmark subset')
+    if not any(r['task']==args.task and r['setting']==args.setting and r['index']==args.index
+               for r in subset.plan):
+        raise ValueError('Requested episode is not in the fixed benchmark')
+    return [sys.executable,str(ROOT/'scripts/hybrid_worker.py'),*common,
+            '--mode','evaluate','--task',args.task,'--setting',args.setting,'--index',str(args.index),
+            '--condition','a100','--planner-initialization','skip_unused',
+            '--manifest-dir',str(subset.manifest_dir),
+            '--evaluation-protocol',subset.protocol['runtime_protocol'],
+            '--subset-id',subset.protocol['subset_id'],'--subset-commit',subset.commit]
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('mode',choices=['server','episode'])
+    parser.add_argument('--epoch',required=True,choices=['ep2','ep6'])
+    parser.add_argument('--output',type=Path,required=True)
+    parser.add_argument('--port',type=int,default=9340)
+    parser.add_argument('--subset',type=Path)
+    parser.add_argument('--task')
+    parser.add_argument('--setting',choices=['clean','randomized'])
+    parser.add_argument('--index',type=int,default=0)
+    parser.add_argument('--run',action='store_true')
+    args = parser.parse_args(argv)
+    if not 1 <= args.port <= 65535 or not 0 <= args.index < 10:
+        parser.error('Invalid port or benchmark episode index')
+    cmd = command(args)
+    if not args.run:
+        print(json.dumps({'status':'plan_only_no_gpu_or_server_started','epoch':args.epoch,'command':cmd}))
+        return
+    env = dict(os.environ, E5_EPOCH=args.epoch, EVAL_RENDER_SHADER='rt',
+               HF_HUB_OFFLINE='1', HF_HUB_DISABLE_TELEMETRY='1',
+               PYTHONPATH=os.pathsep.join([str(ROOT),str(ROOT/'scripts'),str(ROOT/'third_party/lingbot-vla-v2')]))
+    subprocess.run(cmd,cwd=ROOT,env=env,check=True)
+
+
+if __name__ == '__main__':
+    main()

scripts/serve_eval_policy.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Official policy inference, strict streaming load, explicit evaluation precision."""
+import argparse
+from collections import Counter
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+import time
+
+from eval_diagnostics import emit_startup, record_startup_failure
+from eval_model_registry import MODEL_NAMES, verify_checkpoint
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--model', choices=MODEL_NAMES, required=True)
+    p.add_argument('--precision', choices=['bf16', 'fp32'], required=True)
+    p.add_argument('--output', type=Path, required=True)
+    p.add_argument('--port', type=int, default=9340)
+    args = p.parse_args()
+    try:
+        emit_startup(args.output, 'python_entry', role='policy', model=args.model,
+                     precision=args.precision)
+        serve_policy(args)
+    except BaseException as error:
+        record_startup_failure(args.output, error)
+        raise
+
+
+def serve_policy(args):
+    args.output.mkdir(parents=True, exist_ok=True)
+    checkpoint_metadata = {}
+    if args.model == 'e5':
+        checkpoint, norm, checkpoint_metadata = verify_checkpoint(ROOT)
+        (args.output / 'checkpoint_verified.json').write_text(
+            json.dumps(checkpoint_metadata, indent=2) + '\n')
+    upstream = ROOT / 'third_party/lingbot-vla-v2'
+    os.environ['QWEN3VL_PATH'] = str(ROOT / 'checkpoints/dependencies/Qwen3-VL-4B-Instruct')
+    os.environ['HF_HUB_OFFLINE'] = '1'
+    os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+    emit_startup(args.output, 'torch_import_started')
+    import torch
+    emit_startup(args.output, 'torch_import_complete')
+    emit_startup(args.output, 'policy_imports_started')
+    from src.phase4_policy import load_base_policy, streaming_server_class
+    emit_startup(args.output, 'policy_imports_complete')
+    torch.set_num_threads(8)
+    emit_startup(args.output, 'policy_loading', model=args.model, precision=args.precision)
+    started = time.monotonic()
+    if args.model == 'base':
+        norm = ROOT / 'manifests/norm_stats/robotwin_clean_train_s7.json'
+        policy = load_base_policy(ROOT / 'checkpoints/base/lingbot-vla-v2-6b',
+            Path(os.environ['QWEN3VL_PATH']), norm, args.output / 'runtime',
+            use_bf16=args.precision == 'bf16', use_compile=False, use_length=50, chunk_ret=True)
+    elif args.model == 'robotwin':
+        # Keep the released post-training config, including its architecture.
+        # No train-only normalization substitution for this released checkpoint.
+        norm = upstream / 'assets/norm_stats/robotwin.json'
+        checkpoint = ROOT / 'checkpoints/official/lingbot-vla-v2-6b-robotwin/checkpoints/global_step_50000/hf_ckpt'
+        cls = streaming_server_class(upstream)
+        policy = cls(path_to_pi_model=str(checkpoint), robot_norm_path=str(norm),
+                     use_bf16=args.precision == 'bf16', use_fp32=args.precision == 'fp32',
+                     use_compile=False, use_length=50, chunk_ret=True)
+        policy.reset('robotwin')
+    elif args.model == 'e5':
+        cls = streaming_server_class(upstream)
+        policy = cls(path_to_pi_model=str(checkpoint), robot_norm_path=str(norm),
+                     use_bf16=args.precision == 'bf16', use_fp32=args.precision == 'fp32',
+                     use_compile=False, use_length=50, chunk_ret=True)
+        policy.reset('robotwin')
+    elif args.model == 'lora8':
+        if args.precision != 'fp32':
+            raise ValueError('The validated LoRA profile requires FP32 inference')
+        from src.lora_eval_policy import load_lora_policy
+        from eval_model_registry import validate_lora_identity
+        policy, norm, checkpoint_metadata = load_lora_policy(ROOT, args.output)
+        validate_lora_identity(checkpoint_metadata, ROOT)
+    else:
+        raise ValueError('Unknown model: ' + args.model)
+    # Upstream constructor sets 'high'. Apply the frozen strict-FP32 protocol AFTER loading.
+    torch.set_float32_matmul_precision('highest')
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    expected = torch.bfloat16 if args.precision == 'bf16' else torch.float32
+    dtypes = Counter(str(x.dtype) for x in policy.vla.parameters())
+    if any(x.dtype != expected for x in policy.vla.parameters()):
+        raise RuntimeError(f'Unexpected parameter dtype: {dtypes}')
+    original_infer = policy.infer
+
+    def controlled_infer(observation):
+        # A stable per-episode RNG prevents order/retries/warmup from changing actions.
+        if observation.get('reset'):
+            from deploy.lingbot_vla_v2_policy import set_seed_everywhere
+            set_seed_everywhere(int(observation.get('policy_seed', 42)))
+        with torch.inference_mode(), torch.autocast('cuda', enabled=False):
+            return original_infer(observation)
+
+    policy.infer = controlled_infer
+    torch.cuda.synchronize()
+    initialization_seconds = time.monotonic()-started
+    emit_startup(args.output, 'policy_loaded', initialization_seconds=initialization_seconds)
+    # Warm inference before starting any simulator. This avoids retaining an
+    # extra rendered scene just for warmup on a memory-constrained GPU.
+    emit_startup(args.output, 'warmup_imports_started')
+    import cv2
+    import h5py
+    import numpy as np
+    emit_startup(args.output, 'warmup_started')
+    warm_started = time.monotonic()
+    with h5py.File(ROOT/'data/raw/adjust_bottle/aloha-agilex_clean_50/data/episode0.hdf5', 'r') as f:
+        warm = {'task': 'Adjust the bottle.'}
+        for key, raw in [('cam_high','head_camera'),('cam_left_wrist','left_camera'),('cam_right_wrist','right_camera')]:
+            encoded = np.frombuffer(f[f'observation/{raw}/rgb'][0], dtype=np.uint8)
+            warm[f'observation.images.{key}'] = cv2.resize(cv2.imdecode(encoded, cv2.IMREAD_COLOR), (320,240))
+        warm['observation.state'] = np.concatenate([np.asarray(f[f'joint_action/{key}'][0]).reshape(-1)
+            for key in ['left_arm','left_gripper','right_arm','right_gripper']]).astype(np.float32)
+    if args.model == 'e5':
+        from e5_rollout_history import empty_history
+        warm.update(empty_history())
+    for _ in range(3):
+        value = policy.infer(warm)['action']
+        assert value.shape == (50,14) and np.isfinite(value).all()
+    torch.cuda.synchronize()
+    torch.cuda.empty_cache()
+    warm_seconds = time.monotonic()-warm_started
+    emit_startup(args.output, 'warmup_complete', warmup_seconds=warm_seconds)
+    metadata = {'model': args.model, 'precision': args.precision, 'compile': False,
+                'tf32': False, 'matmul_precision': torch.get_float32_matmul_precision(),
+                'autocast': False, 'parameter_dtypes': dict(dtypes),
+                'parameters': policy.loaded_parameter_count, 'tensors': policy.loaded_tensor_count,
+                'initialization_seconds': initialization_seconds, 'warmup_seconds': warm_seconds,
+                'warmup': '3 offline clean-observation calls before simulator startup; RNG reset at each evaluated episode',
+                'norm_path': str(norm), 'norm_sha256': hashlib.sha256(norm.read_bytes()).hexdigest(),
+                'attention_implementation': policy.config.attention_implementation,
+                'attn_implementation': getattr(policy.config, 'attn_implementation', None),
+                'vit_attn_implementation': getattr(policy.config, 'vit_attn_implementation', None),
+                'use_length': 50, 'chunk_ret': True, 'denoising_steps': policy.config.num_steps,
+                'vision_attention_precision_note': 'Official FA2 vision patch internally casts FP32 Q/K/V to BF16, then restores output dtype; FP32 here denotes official FP32 parameter/main-path mode, not all operations IEEE FP32.'}
+    if args.model == 'e5':
+        assert policy.config.action_history_mode == 'summary'
+        assert (policy.config.action_history_length, policy.config.action_history_mlp_hidden_size) == (8,1024)
+        assert policy.config.visual_history_mode == 'none'
+        assert policy.config.state_history_mode == 'tokens'
+        assert policy.config.state_history_length == 2 and policy.config.state_history_stride == 50
+        metadata.update(action_history_mode='summary', action_history_length=8, action_history_mlp_hidden_size=1024, visual_history_mode='none', state_history_mode='tokens', state_history_length=2,
+                        state_history_stride=50, history_source='public_observation_state',
+                        history_normalization='action offset0 for executed actions; train current-state features for public states',
+                        history_semantics='prior public drive-target observations at policy decisions; not measured qpos')
+    metadata.update(checkpoint_metadata)
+    (args.output / 'server_metadata.json').write_text(json.dumps(metadata, indent=2)+'\n')
+    print(json.dumps({'event': 'ready', **metadata}), flush=True)
+    emit_startup(args.output, 'websocket_server_constructing', port=args.port)
+    from deploy.websocket_policy_server import WebsocketPolicyServer
+    server = WebsocketPolicyServer(policy, host='127.0.0.1', port=args.port, metadata=metadata)
+    emit_startup(args.output, 'policy_ready', startup_complete=True, port=args.port)
+    server.serve_forever()
+
+
+if __name__ == '__main__':
+    main()

scripts/serve_hybrid_concurrent_policy.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Serve isolated RoboTwin sessions through one shared A100 policy replica."""
+import argparse
+import json
+from pathlib import Path
+
+from hybrid_concurrent_server import ConcurrentHybridPolicyServer
+from serve_eval_policy import serve_policy
+from eval_model_registry import MODEL_NAMES
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--model', choices=MODEL_NAMES, default='robotwin')
+    parser.add_argument('--precision', choices=['bf16', 'fp32'], default='fp32')
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--port', type=int, default=9340)
+    parser.add_argument('--max-clients', type=int, choices=range(1, 9), default=4)
+    args = parser.parse_args()
+    args.output = args.output.resolve()
+    from deploy import websocket_policy_server
+    original = websocket_policy_server.WebsocketPolicyServer
+
+    class ConfiguredServer(ConcurrentHybridPolicyServer):
+        def __init__(self, *positional, **kwargs):
+            super().__init__(*positional, **kwargs, max_clients=args.max_clients,
+                             log_path=args.output / 'hybrid_server_requests.jsonl')
+            (args.output / 'server_metadata.json').write_text(
+                json.dumps(self.metadata, indent=2) + '\n')
+            print(json.dumps({'event': 'hybrid_ready', **self.metadata}), flush=True)
+
+    # Preserve the existing strict streaming loader, official FP32 semantics,
+    # TF32 flags and exactly the same three offline warmup calls.
+    websocket_policy_server.WebsocketPolicyServer = ConfiguredServer
+    try:
+        serve_policy(args)
+    finally:
+        websocket_policy_server.WebsocketPolicyServer = original
+
+
+if __name__ == '__main__':
+    main()

src/lora_eval_loading.py

@@ -0,0 +1,71 @@
+"""Strict CPU loading helpers for the unwrapped LingBot rank-8 adapter.
+
+These helpers do not select training preprocessing or normalization. Those must
+come from the training run before constructing a policy for closed-loop use.
+"""
+import re
+
+
+def expand_fused_experts(state):
+    """Convert official [expert, out, in] weights to eager nn.Linear keys."""
+    result = {}
+    for name, tensor in state.items():
+        match = re.fullmatch(r"(.+\.experts)\.(gate_proj|up_proj|down_proj)", name)
+        if match:
+            if tensor.ndim != 3:
+                raise ValueError("Fused expert must have three dimensions: " + name)
+            items = [(f"{match[1]}.{i}.{match[2]}.weight", value)
+                     for i, value in enumerate(tensor.unbind(0))]
+        else:
+            items = [(name, tensor)]
+        for key, value in items:
+            if key in result:
+                raise ValueError("Duplicate converted key: " + key)
+            result[key] = value
+    return result
+
+
+def validate_adapter(state, targets, expected_weights, rank=8):
+    """Reject partial, malformed or nonfinite adapters before policy startup."""
+    import torch
+
+    expected = {target + suffix for target in targets
+                for suffix in ('.lora_A.weight', '.lora_B.weight')}
+    if set(state) != expected:
+        raise ValueError("Adapter key inventory differs from target modules")
+    for target in targets:
+        a, b = (state[target + suffix]
+                for suffix in ('.lora_A.weight', '.lora_B.weight'))
+        weight = expected_weights[target + '.weight']
+        if (a.ndim != 2 or b.ndim != 2 or a.shape[0] != rank or
+                b.shape[1] != rank or tuple(weight.shape) != (b.shape[0], a.shape[1])):
+            raise ValueError("Adapter/base shape mismatch: " + target)
+        if any(t.dtype != torch.float32 or not torch.isfinite(t).all().item()
+               for t in (a, b)):
+            raise ValueError("Adapter must contain finite FP32 values: " + target)
+
+
+def inject_and_load_adapter(policy, config, state):
+    """Use in-place PEFT injection and verify every loaded adapter value."""
+    import torch
+    from peft import inject_adapter_in_model
+    from peft.utils.save_and_load import set_peft_model_state_dict
+
+    if config.r != 8 or config.lora_alpha != 8 or config.bias != 'none':
+        raise ValueError("This profile requires rank=8, alpha=8, bias=none")
+    if config.modules_to_save or config.use_dora or config.use_rslora:
+        raise ValueError("Unsupported adapter variant")
+    validate_adapter(state, config.target_modules, policy.state_dict(), rank=config.r)
+    policy = inject_adapter_in_model(config, policy, adapter_name='default')
+    loaded = set_peft_model_state_dict(policy, state, adapter_name='default')
+    if loaded.unexpected_keys or any('lora_' in k for k in loaded.missing_keys):
+        raise ValueError("Adapter loading left missing or unexpected adapter keys")
+    actual = policy.state_dict()
+    for key, tensor in state.items():
+        target = key.replace('.lora_A.weight', '.lora_A.default.weight').replace(
+            '.lora_B.weight', '.lora_B.default.weight')
+        if not torch.equal(actual[target].cpu(), tensor.cpu()):
+            raise ValueError("Loaded adapter differs from source: " + key)
+    policy.requires_grad_(False)
+    policy.eval()
+    return policy

src/lora_eval_policy.py

@@ -0,0 +1,95 @@
+"""Rank-8 policy using explicitly assumed official RoboTwin preprocessing."""
+import hashlib
+import json
+from pathlib import Path
+
+ADAPTER_SHA = '51563f4e588174361ef8ad61db63a23da4ec33c0b115095375bd9323025cf5f0'
+CONFIG_SHA = 'f0c1f8f2e9add85ac9bf573feba91ce52fa4bc24fb4927f175a8b7520e877449'
+REVISION = '1d40e50988de2da6a07877e81a0941da3317733b'
+MODEL = 'lora_r8_step10000'
+
+
+def sha(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for data in iter(lambda: f.read(8 * 1024 * 1024), b''):
+            h.update(data)
+    return h.hexdigest()
+
+
+def load_lora_policy(root, output):
+    import torch
+    import yaml
+    from peft import LoraConfig
+    from safetensors import safe_open
+    from safetensors.torch import load_file
+    from src.phase4_policy import prepare_base_runtime, streaming_server_class
+    from src.lora_eval_loading import expand_fused_experts, inject_and_load_adapter
+
+    root, output = Path(root), Path(output)
+    adapter = root / 'outputs/lora_r8_smoke_preparation_20260929/adapter'
+    if sha(adapter/'adapter_model.safetensors') != ADAPTER_SHA or sha(adapter/'adapter_config.json') != CONFIG_SHA:
+        raise ValueError('Frozen adapter checksum mismatch')
+    upstream = root/'third_party/lingbot-vla-v2'
+    norm = upstream/'assets/norm_stats/robotwin.json'
+    base = root/'checkpoints/base/lingbot-vla-v2-6b'
+    # Verify the complete official base, not merely its model name or shapes.
+    manifest = json.loads((root/'manifests/lingbot-vla-v2-6b.json').read_text())
+    if manifest['revision'] != '11c703bf6a5c1f45b3b69168482da11fdbba53d7':
+        raise ValueError('Wrong base revision')
+    index = json.loads((base/'model.safetensors.index.json').read_text())
+    siblings = {x['rfilename']: x for x in manifest['siblings']}
+    for name in sorted(set(index['weight_map'].values())):
+        if sha(base/name) != siblings[name]['lfs']['sha256']:
+            raise ValueError('Base shard checksum mismatch: ' + name)
+    checkpoint, provenance = prepare_base_runtime(base,
+        root/'checkpoints/dependencies/Qwen3-VL-4B-Instruct', norm,
+        output/'runtime', upstream=upstream)
+    yaml_path = output/'runtime/lingbotvla_cli.yaml'
+    cfg = yaml.safe_load(yaml_path.read_text())
+    cfg['model']['moe_implementation'] = 'eager'
+    yaml_path.write_text(yaml.safe_dump(cfg, sort_keys=False))
+
+    class LoraServer(streaming_server_class(upstream)):
+        def load_model_weights(self, path_to_pi_model, strict=True):
+            if not strict:
+                raise ValueError('Strict base loading required')
+            expected = self.vla.state_dict()
+            tensors = {}
+            for name in sorted(set(index['weight_map'].values())):
+                with safe_open(base/name, framework='pt', device='cpu') as shard:
+                    raw = {}
+                    for key in shard.keys():
+                        if index['weight_map'].get(key) != name:
+                            raise ValueError('Wrong shard assignment: ' + key)
+                        t = shard.get_tensor(key)
+                        raw[key] = t.float() if t.is_floating_point() else t
+                    for key, t in expand_fused_experts(raw).items():
+                        if key in tensors or key not in expected or t.shape != expected[key].shape:
+                            raise ValueError('Converted base key/shape mismatch: ' + key)
+                        tensors[key] = t
+                print('Loaded and expanded base shard', name, flush=True)
+            if set(tensors) != set(expected):
+                raise ValueError('Converted base inventory does not match eager policy')
+            self.vla.load_state_dict(tensors, strict=True, assign=True)
+            if any(t.is_meta for t in list(self.vla.parameters()) + list(self.vla.buffers())):
+                raise ValueError('Meta tensors remain after loading')
+            self.vla = inject_and_load_adapter(self.vla,
+                LoraConfig.from_pretrained(str(adapter)),
+                load_file(str(adapter/'adapter_model.safetensors'), device='cpu'))
+            self.loaded_parameter_count = sum(p.numel() for p in self.vla.parameters())
+            self.loaded_tensor_count = len(self.vla.state_dict())
+            print('Strict eager base + complete LoRA loaded', self.loaded_parameter_count, flush=True)
+
+    policy = LoraServer(path_to_pi_model=str(checkpoint), robot_norm_path=str(norm),
+        use_bf16=False, use_fp32=True, use_compile=False, use_length=50, chunk_ret=True)
+    policy.reset('robotwin')
+    metadata = {'checkpoint_source_kind': 'lora_adapter', 'adapter_revision': REVISION,
+        'adapter_sha256': ADAPTER_SHA, 'adapter_config_sha256': CONFIG_SHA,
+        'base_revision': manifest['revision'], 'base_shards_verified': True,
+        'adapter_tensors_verified': 8494, 'lora_rank': 8, 'lora_alpha': 8,
+        'moe_implementation': 'eager', 'training_configuration_verified': False,
+        'configuration_assumption': 'User-authorized official RoboTwin model/preprocessing/normalization; eager expert layout for LoRA',
+        'norm_sha256': sha(norm), 'runtime_yaml_sha256': sha(yaml_path)}
+    (output/'checkpoint_verified.json').write_text(json.dumps(metadata, indent=2)+'\n')
+    return policy, norm, metadata

src/phase4_policy.py

@@ -0,0 +1,189 @@
+"""Reusable official base-policy loading for local Phase 4 interface checks.
+
+Only construction/loading changes: parameters are constructed on meta and loaded
+in the requested dtype on CPU before official device placement. The upstream
+inference implementation, action transform, and websocket protocol are retained.
+This is a base checkpoint, not a RoboTwin-finetuned evaluation checkpoint.
+"""
+
+import contextlib
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_UPSTREAM = ROOT / "third_party/lingbot-vla-v2"
+_CONSTRUCTION_LOCK = threading.RLock()
+
+
+@contextlib.contextmanager
+def upstream_working_directory(path):
+    previous = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(previous)
+
+
+def prepare_base_runtime(base_path, qwen_path, norm_stats_path, runtime_dir, upstream=DEFAULT_UPSTREAM):
+    """Build the directory topology expected by the unchanged official loader."""
+    import yaml
+
+    base_path = Path(base_path).resolve()
+    qwen_path = Path(qwen_path).resolve()
+    norm_stats_path = Path(norm_stats_path).resolve()
+    runtime_dir = Path(runtime_dir).resolve()
+    upstream = Path(upstream).resolve()
+    index_path = base_path / "model.safetensors.index.json"
+    index = json.loads(index_path.read_text())
+    if not index.get("weight_map"):
+        raise ValueError("Checkpoint index has no weight_map")
+    shard_names = sorted(set(index["weight_map"].values()))
+    if any(Path(name).name != name or not name.endswith(".safetensors") for name in shard_names):
+        raise ValueError("Expected plain safetensors shard filenames in checkpoint index")
+    for name in shard_names:
+        if not (base_path / name).is_file():
+            raise FileNotFoundError(base_path / name)
+    if not (qwen_path / "config.json").is_file() or not norm_stats_path.is_file():
+        raise FileNotFoundError("Qwen config and normalization statistics must exist locally")
+    # Fused MoE weights contain 3D experts.*_proj; eager uses experts.N.*.weight.
+    eager_keys = [key for key in index["weight_map"] if ".experts." in key and key.endswith(".weight")]
+    fused_keys = [key for key in index["weight_map"] if ".experts." in key and key.endswith((".gate_proj", ".up_proj", ".down_proj"))]
+    if eager_keys or not fused_keys:
+        raise ValueError("This base loader expects the released fused-MoE checkpoint; no automatic key conversion is performed")
+    cfg = yaml.safe_load((upstream / "configs/vla/robotwin/robotwin.yaml").read_text())
+    if cfg["model"].get("moe_implementation") != "fused":
+        raise ValueError("Official runtime configuration must retain fused MoE for these weights")
+    cfg["model"]["model_path"] = str(base_path)
+    cfg["model"]["tokenizer_path"] = str(qwen_path)
+    # The training argument parser serializes these dict-like values as strings.
+    for key in ("joints", "norm_type"):
+        cfg["data"][key] = [str(value) for value in cfg["data"][key]]
+    cfg["data"]["norm_stats_file"] = str(norm_stats_path)
+    cfg["data"]["img_size"] = 256
+    cfg["train"]["use_compile"] = False
+    hf_checkpoint = runtime_dir / "checkpoints/global_step_0/hf_ckpt"
+    hf_checkpoint.mkdir(parents=True, exist_ok=True)
+    for name in shard_names + [index_path.name]:
+        target = base_path / name
+        link = hf_checkpoint / name
+        if link.exists() or link.is_symlink():
+            if not link.is_symlink() or link.resolve() != target:
+                raise FileExistsError(f"Runtime checkpoint entry conflicts with requested source: {link}")
+        else:
+            link.symlink_to(target)
+    configuration_path = runtime_dir / "lingbotvla_cli.yaml"
+    configuration_text = yaml.safe_dump(cfg, sort_keys=False)
+    if configuration_path.exists() and configuration_path.read_text() != configuration_text:
+        raise FileExistsError(f"Use a fresh runtime directory for changed configuration: {runtime_dir}")
+    configuration_path.write_text(configuration_text)
+    provenance = {"base_path": str(base_path), "qwen_path": str(qwen_path),
+        "norm_stats_path": str(norm_stats_path), "upstream": str(upstream),
+        "checkpoint_index_sha256": hashlib.sha256(index_path.read_bytes()).hexdigest(),
+        "checkpoint_tensor_count": len(index["weight_map"]), "checkpoint_shard_count": len(shard_names),
+        "checkpoint_expert_layout": "fused", "fused_expert_tensor_count": len(fused_keys),
+        "base_checkpoint_only": True, "robotwin_finetuning_performed": False}
+    (runtime_dir / "runtime_source.json").write_text(json.dumps(provenance, indent=2) + "\n")
+    return hf_checkpoint, provenance
+
+
+def streaming_server_class(upstream=DEFAULT_UPSTREAM):
+    """Return a subclass with the official constructor, infer, and reset interface."""
+    import torch
+    from accelerate import init_empty_weights
+    from safetensors import safe_open
+
+    upstream = Path(upstream).resolve()
+    if str(upstream) not in sys.path:
+        sys.path.insert(0, str(upstream))
+    import deploy.lingbot_vla_v2_policy as official
+
+    class StreamingBaseServer(official.LingbotVLAv2Server):
+        def __init__(self, *args, **kwargs):
+            # Official use_bf16 is positional argument 6, default True.
+            use_bf16 = kwargs.get("use_bf16", args[6] if len(args) > 6 else True)
+            self._checkpoint_dtype = torch.bfloat16 if use_bf16 else torch.float32
+            with upstream_working_directory(upstream):
+                super().__init__(*args, **kwargs)
+
+        def load_vla(self, path_to_pi_model):
+            with _CONSTRUCTION_LOCK, upstream_working_directory(upstream):
+                original = official.LingBotVlaV2InferencePolicy
+
+                def empty_constructor(*args, **kwargs):
+                    # Keep initialized buffers on CPU. Meta is only for parameters;
+                    # putting nonpersistent rotary buffers on meta loses their values.
+                    with init_empty_weights(include_buffers=False):
+                        return original(*args, **kwargs)
+
+                official.LingBotVlaV2InferencePolicy = empty_constructor
+                try:
+                    return super().load_vla(path_to_pi_model)
+                finally:
+                    official.LingBotVlaV2InferencePolicy = original
+
+        def load_model_weights(self, path_to_pi_model, strict=True):
+            if not strict:
+                raise ValueError("The base-policy wrapper requires strict checkpoint loading")
+            path = Path(path_to_pi_model)
+            index = json.loads((path / "model.safetensors.index.json").read_text())
+            expected = self.vla.state_dict()
+            index_keys = set(index["weight_map"])
+            if set(expected) != index_keys:
+                missing = sorted(set(expected) - index_keys)
+                unexpected = sorted(index_keys - set(expected))
+                raise ValueError(f"Checkpoint/model key mismatch before tensor loading; missing={missing[:20]}, unexpected={unexpected[:20]}")
+            tensors = {}
+            for name in sorted(set(index["weight_map"].values())):
+                with safe_open(path / name, framework="pt", device="cpu") as shard:
+                    for key in shard.keys():
+                        if key in tensors:
+                            raise ValueError(f"Duplicate checkpoint key: {key}")
+                        if key not in expected or index["weight_map"].get(key) != name:
+                            raise ValueError(f"Unexpected checkpoint key/shard assignment: {key} in {name}")
+                        tensor = shard.get_tensor(key)
+                        if tensor.shape != expected[key].shape:
+                            raise ValueError(f"Checkpoint shape mismatch: {key}, {tensor.shape} != {expected[key].shape}")
+                        tensors[key] = tensor.to(self._checkpoint_dtype) if tensor.is_floating_point() else tensor
+                print("Loaded shard", name, flush=True)
+            result = self.vla.load_state_dict(tensors, strict=True, assign=True)
+            if result.missing_keys or result.unexpected_keys:
+                raise ValueError(f"Strict checkpoint load failed: {result}")
+            remaining_meta = [name for name, value in list(self.vla.named_parameters()) + list(self.vla.named_buffers()) if value.is_meta]
+            if remaining_meta:
+                raise ValueError(f"Uninitialized meta tensors after strict loading: {remaining_meta[:20]}")
+            self.loaded_parameter_count = sum(param.numel() for param in self.vla.parameters())
+            self.loaded_tensor_count = len(tensors)
+            print("Strict load complete; parameters", self.loaded_parameter_count, "tensors", self.loaded_tensor_count, flush=True)
+
+        def reset(self, robo_name, path_to_pi_model=None):
+            # Upstream reset resolves configs/robot_configs relative to cwd.
+            with upstream_working_directory(upstream):
+                return super().reset(robo_name, path_to_pi_model)
+
+    return StreamingBaseServer
+
+
+def load_base_policy(base_path, qwen_path, norm_stats_path, runtime_dir,
+        upstream=DEFAULT_UPSTREAM, use_bf16=True, use_compile=False,
+        use_length=50, chunk_ret=True, robo_name="robotwin"):
+    """Strictly load and reset the official policy; `.infer()` stays upstream's."""
+    qwen_path = Path(qwen_path).resolve()
+    norm_stats_path = Path(norm_stats_path).resolve()
+    os.environ["QWEN3VL_PATH"] = str(qwen_path)
+    os.environ.setdefault("HF_HUB_OFFLINE", "1")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+    checkpoint, provenance = prepare_base_runtime(base_path, qwen_path,
+        norm_stats_path, runtime_dir, upstream=upstream)
+    server_type = streaming_server_class(upstream)
+    policy = server_type(path_to_pi_model=str(checkpoint), robot_norm_path=str(norm_stats_path),
+        use_bf16=use_bf16, use_fp32=not use_bf16, use_compile=use_compile,
+        use_length=use_length, chunk_ret=chunk_ret)
+    policy.reset(robo_name)
+    policy.phase4_source = provenance
+    return policy

third_party/lingbot-vla-v2/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

third_party/lingbot-vla-v2/configs/robot_configs/agilex_cobot_magic.yaml

@@ -0,0 +1,20 @@
+states:
+  - observation.state.arm.position:
+      origin_keys: observation.state.arm.position
+  - observation.state.effector.position:
+      origin_keys: observation.state.effector.position
+
+actions:
+  - action.arm.position:
+      origin_keys: action.arm.position
+      subtract_state: true
+  - action.effector.position:
+      origin_keys: action.effector.position
+      subtract_state: false
+
+images:
+  - observation.images.camera_top
+  - observation.images.camera_wrist_left
+  - observation.images.camera_wrist_right
+
+norm_stats: assets/norm_stats/example.json

third_party/lingbot-vla-v2/configs/robot_configs/robotwin.yaml

@@ -0,0 +1,49 @@
+states:
+  - observation.state.arm.position:
+      origin_keys:
+        - observation.state:
+            start: 0
+            end: 6
+        - observation.state:
+            start: 7
+            end: 13
+
+  - observation.state.effector.position: 
+      origin_keys:
+        - observation.state:
+            start: 6
+            end: 7
+        - observation.state:
+            start: 13
+            end: 14
+
+actions:
+  - action.arm.position: 
+      origin_keys:
+          - action:
+              start: 0
+              end: 6
+          - action:
+              start: 7
+              end: 13
+      subtract_state: False
+
+  - action.effector.position: 
+      origin_keys:
+          - action:
+              start: 6
+              end: 7
+          - action:
+              start: 13
+              end: 14
+      subtract_state: False
+  
+images:
+  - observation.images.camera_top: 
+      origin_keys:  observation.images.cam_high
+  - observation.images.camera_wrist_left: 
+      origin_keys: observation.images.cam_left_wrist
+  - observation.images.camera_wrist_right: 
+      origin_keys: observation.images.cam_right_wrist
+
+norm_stats: assets/norm_stats/robotwin.json

third_party/lingbot-vla-v2/configs/vla/norm_compute/post_data.yaml

@@ -0,0 +1,15 @@
+data:
+  datasets_type: vla
+  data_name: multi
+  robot_name: 
+  train_path: 
+  robot_config_root: configs/robot_configs
+  norm_path: 
+  num_workers: 8
+  prompt_type: global
+  
+
+train:
+  micro_batch_size: 48
+  output_dir: ''
+  max_steps: 100000000000000

third_party/lingbot-vla-v2/configs/vla/real_robot/real_robot.yaml

@@ -0,0 +1,146 @@
+model:
+  model_path: /path/to/pretain_ckpt/hf_ckpt
+  tokenizer_path: /path/to/Qwen3-VL-4B-Instruct
+  post_training: true
+  adanorm_time: true
+  config_key: LingbotVLAV2Config
+  moe_implementation: fused
+
+data:
+  datasets_type: vla
+  data_name: multi
+  train_path: path/to/training_data.txt (e.g., assets/training_data/robotwin.txt)
+  robot_config_root: configs/robot_configs
+  joints:
+    - arm.position: 14
+    - end.position: 14
+    - effector.position: 2
+    - waist.position: 4
+    - head.position: 2
+    - base.position: 3
+    - hand.position: 12
+  cameras:
+    - camera_top
+    - camera_wrist_left
+    - camera_wrist_right
+  norm_type: 
+    - arm.position: meanstd
+    - end.position: meanstd
+    - effector.position: meanstd
+    - waist.position: meanstd
+    - head.position: meanstd
+    - base.position: meanstd
+    - hand.position: meanstd
+  num_workers: 8
+  use_future_image: true
+
+train:
+  output_dir: /path/to/save_ckpt
+  moe_monitor_interval: 1000
+  enable_gradient_checkpointing: false # Set to true if GPU memory is insufficient, but this will slow down training.
+  precompute_grid_thw: true
+  vlm_causal: true
+  vlm_fsdp: true
+  attention_implementation: flex_cached
+  use_moe: true
+  token_moe_layers: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35]
+  token_num_experts: 32
+  token_top_k: 4
+  token_moe_intermediate_size: 512
+  token_shared_intermediate_size: 704
+  bias_update_speed: 0
+  sequence_wise_mode: "per_sequence"
+  sequence_wise_loss_coeff: 1e-3
+  router_z_loss_coeff: 1e-4
+  router_activation: "sigmoid"
+  routed_scaling_factor: 4.0
+  use_shared_expert_gate: false
+  use_moe_expert_lr: true
+  data_parallel_mode: fsdp2
+  enable_full_shard: false
+  module_fsdp_enable: true
+  use_compile: true
+  use_wandb: false
+  rmpad: false
+  rmpad_with_pos_ids: false
+  ulysses_parallel_size: 1
+  freeze_vision_encoder: false
+  tokenizer_max_length: 72
+  action_dim: 55
+  max_action_dim: 55
+  max_state_dim: 55
+  optimizer: muon
+  lr: 5.0e-5
+  lr_decay_style: constant
+  num_train_epochs: 29000
+  micro_batch_size: 32
+  global_batch_size: 256
+  max_steps: 60000
+  ckpt_manager: dcp
+  save_steps: 20000
+  save_epochs: 29000
+  enable_fp32: true
+  enable_resume: true
+  align_params:
+    mode: 'query'
+    num_task_tokens: 8
+    depth_loss_weight: 0.004
+    future_depth_loss_weight: 0.004
+    use_future_video: true
+    llm:
+      dim_out: 2560
+      image_token_size: 8
+      image_input_size: 224
+    depth:
+      model_type: MoRGBD
+      moge_path: /path/to/depth/moge2-vitb-normal.pt
+      morgbd_path: /path/to/depth/model.pt
+      num_layers: 1
+      num_heads: 4
+      dim_head: 32
+      ff_mult: 1
+      num_backbone_tokens: 256
+      token_size: 16
+      dim_out: 1024
+      input_size: 224
+      use_future_depth: true
+      block_future_depth_to_action: false
+      detach_future_image_feats: true
+    video:
+      ckpt_path: /path/to/dino_video/teacher_step_10000.pth
+      config_path: /path/to/dino_video/config.yaml
+      attention_mode: flex_block_causal
+      input_size: 256
+      block_suffix_to_future_video: false
+      share_future_depth_query: true
+      use_shared_future_task_proj: true
+      use_current_shared_task_proj: true
+      num_future_frames: 1
+      # Keeps DINO teacher input as [warmup current, current, future].
+      # Current-DINO target uses current_index=1 in code.
+      use_warmup_frame: true
+      effective_fps: 1.0
+      n_blocks: 1
+      cls_pool: last
+      detach_image_feats: true
+      num_layers: 1
+      num_heads: 4
+      dim_head: 32
+      ff_mult: 1
+      num_backbone_tokens: 256
+      dim_out: 1024
+      future_video_loss_weight: 0.004
+      use_smooth_l1_loss: false
+      use_mse_loss: true
+      mse_loss_weight: 1.0
+      # Enables current-DINO patch alignment and current depth/DINO shared query projection.
+      use_patch_loss: true
+      use_current_patch_loss: true
+      use_cosine_loss: true
+      cosine_loss_weight: 0.2
+      use_cls_loss: false
+      cls_loss_type: mse
+      cls_loss_weight: 0.2
+      log_max_samples: 32
+      log_scale: 16
+    visual_steps: 5000

third_party/lingbot-vla-v2/configs/vla/robotwin/robotwin.yaml

@@ -0,0 +1,140 @@
+model:
+  model_path: /path/to/pretain_ckpt/hf_ckpt
+  tokenizer_path: /path/to/Qwen3-VL-4B-Instruct
+  post_training: true
+  adanorm_time: true
+  config_key: LingbotVLAV2Config
+  moe_implementation: fused
+
+data:
+  datasets_type: vla
+  data_name: multi
+  train_path: assets/training_data/robotwin.txt
+  robot_config_root: ./configs/robot_configs
+  joints:
+    - arm.position: 14
+    - end.position: 14
+    - effector.position: 2
+  cameras:
+    - camera_top
+    - camera_wrist_left
+    - camera_wrist_right
+  norm_type:
+    - arm.position: bounds_99_woclip
+    - end.position: bounds_99_woclip
+    - effector.position: bounds_99_woclip
+  num_workers: 8
+  use_future_image: true
+
+train:
+  output_dir: /path/to/save_ckpt
+  moe_monitor_interval: 1000
+  enable_gradient_checkpointing: false # Set to true if GPU memory is insufficient, but this will slow down training.
+  precompute_grid_thw: true
+  vlm_causal: true
+  vlm_fsdp: true
+  attention_implementation: flex_cached
+  use_moe: true
+  token_moe_layers: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35]
+  token_num_experts: 32
+  token_top_k: 4
+  token_moe_intermediate_size: 512
+  token_shared_intermediate_size: 704
+  bias_update_speed: 0
+  sequence_wise_mode: "per_sequence"
+  sequence_wise_loss_coeff: 1e-3
+  router_z_loss_coeff: 1e-4
+  router_activation: "sigmoid"
+  routed_scaling_factor: 4.0
+  use_shared_expert_gate: false
+  use_moe_expert_lr: true
+  loss_type: L1_fm
+  data_parallel_mode: fsdp2
+  enable_full_shard: false
+  module_fsdp_enable: true
+  use_compile: true
+  use_wandb: false
+  rmpad: false
+  rmpad_with_pos_ids: false
+  ulysses_parallel_size: 1
+  freeze_vision_encoder: false
+  tokenizer_max_length: 72
+  action_dim: 55
+  max_action_dim: 55
+  max_state_dim: 55
+  lr: 1.0e-4
+  lr_min: 5.0e-5
+  lr_decay_style: cosine
+  optimizer: muon
+  num_train_epochs: 29000
+  micro_batch_size: 32
+  global_batch_size: 1024 # Training uses 32 GPUs: global_batch_size = micro_batch_size * 32
+  max_steps: 50000
+  ckpt_manager: dcp
+  save_steps: 10000
+  save_epochs: 29000
+  enable_fp32: true
+  enable_resume: true
+  align_params:
+    mode: 'query'
+    num_task_tokens: 8
+    depth_loss_weight: 0.004
+    future_depth_loss_weight: 0.004
+    use_future_video: true
+    llm:
+      dim_out: 2560
+      image_token_size: 8
+      image_input_size: 224
+    depth:
+      model_type: MoRGBD
+      moge_path: /path/to/depth/moge2-vitb-normal.pt
+      morgbd_path: /path/to/depth/model.pt
+      num_layers: 1
+      num_heads: 4
+      dim_head: 32
+      ff_mult: 1
+      num_backbone_tokens: 256
+      token_size: 16
+      dim_out: 1024
+      input_size: 224
+      use_future_depth: true
+      block_future_depth_to_action: false
+      detach_future_image_feats: true
+    video:
+      ckpt_path: /path/to/dino_video/teacher_step_10000.pth
+      config_path: /path/to/dino_video/config.yaml
+      attention_mode: flex_block_causal
+      input_size: 256
+      block_suffix_to_future_video: false
+      share_future_depth_query: true
+      use_shared_future_task_proj: true
+      use_current_shared_task_proj: true
+      num_future_frames: 1
+      # Keeps DINO teacher input as [warmup current, current, future].
+      # Current-DINO target uses current_index=1 in code.
+      use_warmup_frame: true
+      effective_fps: 1.0
+      n_blocks: 1
+      cls_pool: last
+      detach_image_feats: true
+      num_layers: 1
+      num_heads: 4
+      dim_head: 32
+      ff_mult: 1
+      num_backbone_tokens: 256
+      dim_out: 1024
+      future_video_loss_weight: 0.004
+      use_smooth_l1_loss: false
+      use_mse_loss: true
+      mse_loss_weight: 1.0
+      # Enables current-DINO patch alignment and current depth/DINO shared query projection.
+      use_patch_loss: true
+      use_current_patch_loss: true
+      use_cosine_loss: true
+      cosine_loss_weight: 0.2
+      use_cls_loss: false
+      cls_loss_type: mse
+      cls_loss_weight: 0.2
+      log_max_samples: 32
+      log_scale: 16
+    visual_steps: 5000

third_party/lingbot-vla-v2/deploy/executed_action_history.py

@@ -0,0 +1,51 @@
+"""Episode-local raw command history for P4-V's explicit inference input.
+
+Call ``record_completed`` only after the environment finishes the submitted
+command's execution interval. Never pass an entire predicted chunk before it
+executes. Commands are at the demonstration's 50 Hz control-row timebase,
+not physics substeps, and are re-normalized using training offset-zero stats.
+"""
+from collections import deque
+import numpy as np
+
+
+class ExecutedActionHistory:
+    def __init__(self, length=8, action_dim=14, action_key="action"):
+        if length != 8 or action_dim != 14 or action_key != "action":
+            raise ValueError("This protocol is fixed to RoboTwin K=8, raw action14")
+        self.length, self.action_dim, self.action_key = length, action_dim, action_key
+        self._rows = deque(maxlen=length)
+        self.episode_id = None
+        self.completed_steps = 0
+
+    def reset(self, episode_id):
+        if episode_id is None:
+            raise ValueError("An explicit episode identity is required")
+        self._rows.clear()
+        self.episode_id = episode_id
+        self.completed_steps = 0
+
+    def record_completed(self, commands, *, episode_id, start_step):
+        if self.episode_id is None or episode_id != self.episode_id:
+            raise ValueError("Reset history before recording a different episode")
+        if isinstance(start_step, bool) or not isinstance(start_step, int) or start_step != self.completed_steps:
+            raise ValueError("Completed control rows must be contiguous, without duplicates or gaps")
+        values = np.asarray(commands, dtype=np.float32)
+        if values.ndim != 2 or values.shape[1] != self.action_dim:
+            raise ValueError("Expected [completed_control_rows, 14] raw command array")
+        if not np.isfinite(values).all():
+            raise ValueError("Completed commands must be finite")
+        # Copy: caller may reuse/mutate the prediction buffer after execution.
+        for value in values:
+            self._rows.append(value.copy())
+        self.completed_steps += len(values)
+
+    def observation_fields(self):
+        if self.episode_id is None:
+            raise ValueError("Reset history before creating an observation")
+        raw = np.zeros((self.length, self.action_dim), dtype=np.float32)
+        mask = np.zeros(self.length, dtype=bool)
+        if self._rows:
+            raw[-len(self._rows):] = np.stack(self._rows)
+            mask[-len(self._rows):] = True
+        return {"action_history_raw": {self.action_key: raw}, "action_history_mask": mask}

third_party/lingbot-vla-v2/deploy/image_tools.py

@@ -0,0 +1,58 @@
+import numpy as np
+from PIL import Image
+
+
+def convert_to_uint8(img: np.ndarray) -> np.ndarray:
+    """Converts an image to uint8 if it is a float image.
+
+    This is important for reducing the size of the image when sending it over the network.
+    """
+    if np.issubdtype(img.dtype, np.floating):
+        img = (255 * img).astype(np.uint8)
+    return img
+
+
+def resize_with_pad(images: np.ndarray, height: int, width: int, method=Image.BILINEAR) -> np.ndarray:
+    """Replicates tf.image.resize_with_pad for multiple images using PIL. Resizes a batch of images to a target height.
+
+    Args:
+        images: A batch of images in [..., height, width, channel] format.
+        height: The target height of the image.
+        width: The target width of the image.
+        method: The interpolation method to use. Default is bilinear.
+
+    Returns:
+        The resized images in [..., height, width, channel].
+    """
+    # If the images are already the correct size, return them as is.
+    if images.shape[-3:-1] == (height, width):
+        return images
+
+    original_shape = images.shape
+
+    images = images.reshape(-1, *original_shape[-3:])
+    resized = np.stack([_resize_with_pad_pil(Image.fromarray(im), height, width, method=method) for im in images])
+    return resized.reshape(*original_shape[:-3], *resized.shape[-3:])
+
+
+def _resize_with_pad_pil(image: Image.Image, height: int, width: int, method: int) -> Image.Image:
+    """Replicates tf.image.resize_with_pad for one image using PIL. Resizes an image to a target height and
+    width without distortion by padding with zeros.
+
+    Unlike the jax version, note that PIL uses [width, height, channel] ordering instead of [batch, h, w, c].
+    """
+    cur_width, cur_height = image.size
+    if cur_width == width and cur_height == height:
+        return image  # No need to resize if the image is already the correct size.
+
+    ratio = max(cur_width / width, cur_height / height)
+    resized_height = int(cur_height / ratio)
+    resized_width = int(cur_width / ratio)
+    resized_image = image.resize((resized_width, resized_height), resample=method)
+
+    zero_image = Image.new(resized_image.mode, (width, height), 0)
+    pad_height = max(0, int((height - resized_height) / 2))
+    pad_width = max(0, int((width - resized_width) / 2))
+    zero_image.paste(resized_image, (pad_width, pad_height))
+    assert zero_image.size == (width, height)
+    return zero_image

third_party/lingbot-vla-v2/deploy/lingbot_vla_v2_policy.py

@@ -0,0 +1,700 @@
+import os
+import sys
+import time
+import yaml
+from types import SimpleNamespace
+
+from glob import glob
+from tqdm import tqdm
+from safetensors import safe_open
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from transformers.models.auto.tokenization_auto import AutoTokenizer
+from transformers import (
+    AutoConfig,
+)
+
+from typing import Dict, List, Optional, Type, Union, Tuple
+import numpy as np
+from torch import Tensor
+from safetensors.torch import load_file
+import torch
+from torchvision.transforms.v2 import Resize
+import torch.nn.functional as F
+from lingbotvla.models.vla.lingbot_vla.configuration_lingbot_vla import LingbotVLAV2Config
+from lingbotvla.models.vla.lingbot_vla.modeling_lingbot_vla_v2 import LingbotVlaV2Policy
+from lingbotvla.models.vla.lingbot_vla.qwen3vl_in_vla import apply_lingbot_qwen3_vl_patch
+
+from lingbotvla.data.vla_data.utils import FeatureTransform
+from lingbotvla.models import build_processor
+import time
+import random
+
+def set_seed_everywhere(seed: int):
+    """Sets the random seed for Python, NumPy, and PyTorch functions."""
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    os.environ["PYTHONHASHSEED"] = str(seed)
+
+set_seed_everywhere(42)
+
+BASE_MODEL_PATH = {
+    'qwen3vl': os.environ.get(
+        'QWEN3VL_PATH',
+        'Qwen/Qwen3-VL-4B-Instruct/',
+    ),
+}
+
+class PolicyPreprocessMixin:
+    @staticmethod
+    def _to_device_image_grid_thw(image_grid_thw, device):
+        if image_grid_thw is None:
+            return None
+        return image_grid_thw.to(device=device, dtype=torch.long)
+
+    def _history_kwargs(self, observation, device, dtype):
+        action_mode = getattr(self.config, "action_history_mode", "none")
+        state_mode = getattr(self.config, "state_history_mode", "none")
+        if state_mode == "tokens" and action_mode not in ("none", "summary"):
+            raise ValueError("Only E5 action summary can combine with state history")
+        result = {}
+        for prefix, enabled in (("action_history", action_mode in ("summary", "tokens")),
+                                ("state_history", state_mode == "tokens")):
+            if not enabled:
+                if prefix in observation or prefix + "_mask" in observation:
+                    raise ValueError(f"{prefix} supplied to a disabled branch")
+                continue
+            history = observation.get(prefix)
+            mask = observation.get(prefix + "_mask")
+            if history is None or mask is None:
+                raise ValueError(f"History model requires explicit {prefix} and validity mask")
+            if mask.dtype != torch.bool:
+                raise ValueError(f"{prefix}_mask must be boolean")
+            if history.ndim == 2:
+                history = history.unsqueeze(0)
+            if mask.ndim == 1:
+                mask = mask.unsqueeze(0)
+            result.update({prefix: history.to(device=device, dtype=dtype),
+                           prefix + "_mask": mask.to(device=device)})
+        if getattr(self.config, "visual_history_mode", "none") == "pooled_tokens":
+            pixels = observation.get("visual_history_images")
+            grid = observation.get("visual_history_grid_thw")
+            valid = observation.get("visual_history_mask")
+            if pixels is None or grid is None or valid is None:
+                raise ValueError("E4 inference requires explicit processed visual history")
+            if valid.dtype != torch.bool:
+                raise ValueError("visual_history_mask must be boolean")
+            if pixels.ndim == 4:
+                pixels = pixels.unsqueeze(0)
+                grid = grid.unsqueeze(0)
+            if valid.ndim == 1:
+                valid = valid.unsqueeze(0)
+            if not torch.equal(valid.to(device=device), result["state_history_mask"]):
+                raise ValueError("Visual and state history masks must match")
+            result.update(visual_history_images=pixels.to(device=device, dtype=dtype),
+                          visual_history_grid_thw=grid.to(device=device, dtype=torch.long),
+                          visual_history_mask=valid.to(device=device))
+        return result
+
+    @torch.no_grad
+    def select_action(
+        self, observation: dict[str, Tensor], use_bf16: bool = False
+    ):
+        self.eval()
+        device = 'cuda'
+        if use_bf16:
+            dtype = torch.bfloat16
+        else:
+            dtype = torch.float32
+        s1 = time.time()
+
+        if len(observation['images'].shape) == 4:
+            observation['images'] = observation['images'].unsqueeze(0)
+            observation['img_masks'] = observation['img_masks'].unsqueeze(0)
+
+        actions = self.model.sample_actions(
+            observation['images'].to(dtype=dtype, device=device),
+            observation['img_masks'].to(device=device),
+            observation['lang_tokens'].unsqueeze(0).to(device=device),
+            observation['lang_masks'].unsqueeze(0).to(device=device),
+            observation['state'].unsqueeze(0).to(dtype=dtype, device=device),
+            image_grid_thw=self._to_device_image_grid_thw(observation.get('image_grid_thw'), device),
+            **self._history_kwargs(observation, device, dtype),
+        )
+        delta_time = time.time() - s1
+        print(f'sample_actions cost {delta_time} s')
+        observation['actions'] = actions.squeeze(0).to(dtype=torch.float32, device='cpu')
+        if use_bf16:
+            observation['state'] = observation['state'].to(dtype=torch.float32)
+        data = self.feature_transform.unapply(observation)
+        return data
+
+    @torch.no_grad
+    def sample_actions_batch(
+        self,
+        observation: dict[str, Tensor],
+        use_bf16: bool = False,
+        use_compile: bool = False,
+        capture_time: bool = False,
+        sample_compile_fn: callable = None,
+    ) -> Tensor:
+        """Run one model forward for a batch of already-transformed observations.
+
+        Single-sample inference in ``select_action`` builds a leading batch
+        dimension just before calling ``sample_actions``. For Robocasa vector
+        envs we already collate that dimension in the websocket server, so this
+        method keeps the tensors batched and returns normalized action chunks
+        with shape ``(B, chunk, joint_max_dim)``.
+        """
+        self.eval()
+        device = "cuda"
+        dtype = torch.bfloat16 if use_bf16 else torch.float32
+        s1 = time.time()
+
+        images = observation["images"]
+        img_masks = observation["img_masks"]
+        lang_tokens = observation["lang_tokens"]
+        lang_masks = observation["lang_masks"]
+        state = observation["state"]
+        image_grid_thw = observation.get("image_grid_thw", None)
+
+        has_batch_dim = img_masks.ndim >= 2
+        if not has_batch_dim:
+            images = images.unsqueeze(0)
+            img_masks = img_masks.unsqueeze(0)
+        if lang_tokens.ndim == 1:
+            lang_tokens = lang_tokens.unsqueeze(0)
+            lang_masks = lang_masks.unsqueeze(0)
+        if state.ndim == 1:
+            state = state.unsqueeze(0)
+
+        if capture_time:
+            with torch.inference_mode():
+                for _ in range(3):
+                    _ = sample_compile_fn(
+                            images.to(dtype=dtype, device=device),
+                            img_masks.to(device=device),
+                            lang_tokens.to(device=device),
+                            lang_masks.to(device=device),
+                            state.to(dtype=dtype, device=device),
+                            image_grid_thw=self._to_device_image_grid_thw(image_grid_thw, device),
+                            **self._history_kwargs(observation, device, dtype),
+                    )
+                torch.cuda.synchronize()
+
+                iters = 5
+                starts = [torch.cuda.Event(enable_timing=True) for _ in range(iters)]
+                ends = [torch.cuda.Event(enable_timing=True) for _ in range(iters)]
+                for i in range(iters):
+                    starts[i].record()
+                    actions = sample_compile_fn(
+                                    images.to(dtype=dtype, device=device),
+                                    img_masks.to(device=device),
+                                    lang_tokens.to(device=device),
+                                    lang_masks.to(device=device),
+                                    state.to(dtype=dtype, device=device),
+                                    image_grid_thw=self._to_device_image_grid_thw(image_grid_thw, device),
+                            **self._history_kwargs(observation, device, dtype),
+                    )
+                    ends[i].record()
+                torch.cuda.synchronize()
+                gpu_times = [starts[i].elapsed_time(ends[i]) for i in range(iters)]
+                print(f"sample_actions avg time: {sum(gpu_times)/len(gpu_times):.4f} ms, min time: {min(gpu_times):.4f} ms, max time: {max(gpu_times):.4f} ms")
+        else:
+            actions = sample_compile_fn(
+                            images.to(dtype=dtype, device=device),
+                            img_masks.to(device=device),
+                            lang_tokens.to(device=device),
+                            lang_masks.to(device=device),
+                            state.to(dtype=dtype, device=device),
+                            image_grid_thw=self._to_device_image_grid_thw(image_grid_thw, device),
+                            **self._history_kwargs(observation, device, dtype),
+            )
+
+        delta_time = time.time() - s1
+        print(f"sample_actions batch={actions.shape[0]} cost {delta_time} s")
+        if use_bf16:
+            observation["state"] = observation["state"].to(dtype=torch.float32)
+        return actions.to(dtype=torch.float32, device="cpu")
+
+class LingBotVlaV2InferencePolicy(PolicyPreprocessMixin, LingbotVlaV2Policy):
+    pass # Only combine necessary functions
+
+
+class LingbotVLAv2Server:
+    '''
+    policy wrapper to support action ensemble or chunk execution
+    '''
+    def __init__(
+        self,
+        path_to_pi_model="",
+        robot_norm_path=None,
+        adaptive_ensemble_alpha=0.1,
+        action_ensemble_horizon=8,
+        use_length=1,
+        chunk_ret=False,
+        use_bf16=True,
+        use_fp32=False,
+        use_compile=False,
+    ) -> None:
+        assert not (use_bf16 and use_fp32), 'Bfloat16 or Float32!!!'
+        self.adaptive_ensemble_alpha = adaptive_ensemble_alpha
+        self.action_ensemble_horizon = action_ensemble_horizon
+        self.use_length = use_length
+        self.chunk_ret = chunk_ret
+        self.robot_norm_path = robot_norm_path
+
+        self.task_description = None
+
+        self.use_compile = use_compile
+        apply_lingbot_qwen3_vl_patch()
+
+        self.vla = self.load_vla(path_to_pi_model)
+        if use_bf16:
+            self.vla = self.vla.to(torch.bfloat16).cuda().eval()
+        else:
+            # fp32
+            self.vla.model.float()
+            self.vla = self.vla.cuda().eval()
+
+        self.global_step = 0
+        self.last_action_chunk = None
+        self.last_normalized_action_chunk = None
+        self.use_bf16 = use_bf16
+        self.use_fp32 = use_fp32
+        self.action_key: str= "action"
+
+    def load_model_weights(self, path_to_pi_model, strict=True):
+        all_safetensors = glob(os.path.join(path_to_pi_model, "*.safetensors"))
+        merged_weights = {}
+
+        for file_path in tqdm(all_safetensors):
+            with safe_open(file_path, framework="pt", device="cpu") as f:
+                for key in f.keys():
+                    merged_weights[key] = f.get_tensor(key)
+        self.vla.load_state_dict(merged_weights, strict=strict)
+
+    def merge_qwen_config(self, qwen_config):
+        if hasattr(qwen_config, 'to_dict'):
+            config_dict = qwen_config.to_dict()
+        else:
+            config_dict = qwen_config
+
+        text_keys = {
+            "hidden_size",
+            "intermediate_size",
+            "num_hidden_layers",
+            "num_attention_heads",
+            "num_key_value_heads",
+            "rms_norm_eps",
+            "rope_theta",
+            "vocab_size",
+            "max_position_embeddings",
+            "hidden_act",
+            "tie_word_embeddings",
+            "tokenizer_path",
+        }
+
+        text_config = config_dict.get("text_config", {})
+        for key in text_keys:
+            if key in text_config:
+                setattr(self.config, key, text_config[key])
+                print(f"✅ Merged Qwen3-VL text: {key} = {text_config[key]}")
+            elif key in config_dict:
+                setattr(self.config, key, config_dict[key])
+                print(f"✅ Merged LLM: {key} = {config_dict[key]}")
+
+        if "vision_config" in config_dict:
+            self.config.vision_config = qwen_config.vision_config
+        else:
+            print("⚠️ Warning: 'vision_config' not found in qwen_config!")
+
+    def load_vla(self, path_to_pi_model) -> LingbotVlaV2Policy:
+        print(f"loading model from: {path_to_pi_model}")
+        
+        # load training config
+        training_config_path = Path(path_to_pi_model)/'training_config.yaml'
+        with open(training_config_path, 'r') as f:
+            training_config = yaml.safe_load(f)
+        f.close()
+
+        # update model config according to training config
+        training_model_config = training_config['model']
+        training_model_config.update(training_config['train'])
+        config = LingbotVLAV2Config(**training_model_config)
+        for key, value in training_model_config.items():
+            if not hasattr(config, key):
+                setattr(config, key, value)
+
+        # Set attention_implementation to 'eager' to speed up evaluation.
+        config.attention_implementation = 'eager'
+        
+        # set base model according to training config
+        training_base_model = training_config['model']['tokenizer_path']
+        if 'qwen3' in training_base_model.lower() and 'vl' in training_base_model.lower():
+            model_name = 'qwen3vl'
+        else: 
+            raise ValueError(f"Unsupported base model of {path_to_pi_model}")
+        base_model_path = os.environ.get('QWEN3VL_PATH', training_base_model) or BASE_MODEL_PATH[model_name]
+        config.tokenizer_path = base_model_path
+        self.model_name = model_name
+        
+        self.config = config
+        qwen_config = AutoConfig.from_pretrained(base_model_path)
+        self.merge_qwen_config(qwen_config)
+        config = self.config
+
+        if 'vocab_size' in training_config['model'] and training_config['model']['vocab_size'] != 0:
+            config.vocab_size = training_config['model']['vocab_size']
+        # config.num_steps = 4
+        config.use_cache = True # is necessary in inference
+        # load processors
+        self.processor = build_processor(base_model_path)
+        self.language_tokenizer = self.processor.tokenizer
+        data_config = SimpleNamespace(**training_config['data'])
+        
+        print('Initializing model ... ')
+
+        self.vla = LingBotVlaV2InferencePolicy(config, eval=True)
+
+        self.load_model_weights(path_to_pi_model, strict=True)
+        
+        self.vla.feature_transform = None
+        self.data_config = data_config
+        self.config = config
+        self.vla.model._use_compile_predict_velocity = bool(self.use_compile)
+        self.vla.model._compiled_predict_velocity = None
+        self.sample_actions_fn = self.vla.model.sample_actions
+        if self.use_compile:
+            self.vla.model.qwenvl_with_expert = torch.compile(self.vla.model.qwenvl_with_expert)
+            self.sample_actions_fn = torch.compile(self.vla.model.sample_actions)
+
+        if self.robot_norm_path is None:
+            self.robot_norm_path = data_config.norm_stats_file
+
+        print('Model initialized ... ')
+
+        return self.vla
+
+    def reset(self, robo_name, path_to_pi_model = None) -> None:
+        if path_to_pi_model is not None:
+            self.vla = self.load_vla(path_to_pi_model)
+            if self.use_bf16:
+                self.vla = self.vla.to(torch.bfloat16).cuda().eval()
+            else:
+                #fp32
+                self.vla.model.float()
+                self.vla = self.vla.cuda().eval()
+
+        self.global_step = 0
+        self.last_action_chunk = None
+        self.last_normalized_action_chunk = None
+
+        robot_config = f'configs/robot_configs/{robo_name}.yaml'
+        
+        with open(robot_config, 'r') as f:
+          self.robot_config = yaml.safe_load(f)
+
+        feature_transform = FeatureTransform(robot_config, self.data_config, self.config, self.processor,\
+                    chunk_size=self.config.chunk_size, norm_stats_path=self.robot_norm_path)
+        # Load data processors
+        self.vla.feature_transform = feature_transform
+        self.action_key = feature_transform.org_features["actions"]
+    def resize_image(self, observation):
+        image_features  = self.vla.feature_transform.org_features['images']
+        image_size = getattr(self.data_config, 'img_size', 256)
+        resize = Resize((image_size, image_size))
+        for image_feature in image_features:
+            assert image_feature in observation
+            assert len(observation[image_feature].shape)==3 and observation[image_feature].shape[-1] == 3
+            image = torch.as_tensor(observation[image_feature]).permute(2, 0, 1).contiguous()
+            image = image.to(dtype=torch.float32)
+            observation[image_feature] = resize(image)
+
+    def _unapply_batched_actions(self, transformed_observations, actions):
+        action_chunk = {}
+        for action in self.action_key:
+            action_chunk[action] = []
+
+        outputs = []
+        for transformed, action in zip(transformed_observations, actions):
+            single = dict(transformed)
+            single['actions'] = action.to(dtype=torch.float32, device='cpu')
+            if self.use_bf16 and 'state' in single:
+                single['state'] = single['state'].to(dtype=torch.float32)
+            data = self.vla.feature_transform.unapply(single)
+            
+            for action in self.action_key:
+                # keep action keys after unapply
+                value = data[action]
+                if isinstance(value, torch.Tensor):
+                    value = value.float().cpu().numpy()
+                else:
+                    value = np.asarray(value, dtype=np.float32)
+                action_chunk[action].append(value)
+
+        for action_key in action_chunk.keys():
+            action_chunk[action_key] = np.stack(action_chunk[action_key], axis=0)
+
+        return action_chunk
+
+    def _prepare_model_input(self, observation):
+        # Public history fields are raw reported states or completed actions;
+        # normalize using the same fitted features as their current counterparts.
+        observation = dict(observation)
+        action_mode = getattr(self.vla.config, "action_history_mode", "none")
+        state_mode = getattr(self.vla.config, "state_history_mode", "none")
+        if state_mode != "none" and action_mode not in ("none", "summary"):
+            raise ValueError("Only E5 action summary can combine with state history")
+        visual_mode = getattr(self.vla.config, "visual_history_mode", "none")
+        visual_raw = observation.pop("visual_history_raw", None)
+        visual_mask = observation.pop("visual_history_mask", None)
+        if "visual_history_images" in observation or "visual_history_grid_thw" in observation:
+            raise ValueError("Public inference requires raw camera history, not preprocessed pixels")
+        if visual_mode == "pooled_tokens":
+            if visual_raw is None or visual_mask is None or not isinstance(visual_raw, dict):
+                raise ValueError("E4 inference requires explicit raw visual history and mask at reset and every decision")
+        elif visual_raw is not None or visual_mask is not None:
+            raise ValueError("Visual history supplied to a disabled branch")
+        histories = {}
+        for prefix, enabled in (("action_history", action_mode in ("summary", "tokens")),
+                                ("state_history", state_mode == "tokens")):
+            raw = observation.pop(prefix + "_raw", None)
+            mask = observation.pop(prefix + "_mask", None)
+            if prefix in observation:
+                raise ValueError(f"Public inference takes raw {prefix}, not normalized history")
+            if enabled and (raw is None or mask is None):
+                raise ValueError(f"History inference requires explicit raw {prefix}; use empty masked history at reset")
+            if not enabled and (raw is not None or mask is not None):
+                raise ValueError(f"{prefix} inputs supplied to a model without that history branch enabled")
+            if enabled:
+                if not isinstance(raw, dict):
+                    raise TypeError(f"{prefix}_raw must map original features to strictly past rows")
+                histories[prefix] = (raw, mask)
+        self.resize_image(observation)
+        for k, v in list(observation.items()):
+            if isinstance(v, np.ndarray):
+                observation[k] = torch.from_numpy(v)
+        observation = self.vla.feature_transform.apply(observation, policy_eval=True)
+        for prefix, (raw, mask) in histories.items():
+            raw = {key: torch.as_tensor(value, dtype=torch.float32) for key, value in raw.items()}
+            normalize = getattr(self.vla.feature_transform, "normalize_" + prefix)
+            history, valid = normalize(raw, torch.as_tensor(mask))
+            observation[prefix] = history
+            observation[prefix + "_mask"] = valid
+        if visual_mode == "pooled_tokens":
+            pixels, grid, valid = self.vla.feature_transform.prepare_visual_history(
+                visual_raw, torch.as_tensor(visual_mask), policy_eval=True,
+            )
+            if not torch.equal(valid, observation["state_history_mask"]):
+                raise ValueError("Visual and state history validity masks must match")
+            observation.update(visual_history_images=pixels, visual_history_grid_thw=grid,
+                               visual_history_mask=valid)
+        if self.use_bf16:
+            observation['state'] = observation['state'].to(torch.bfloat16)
+        return observation
+
+    @staticmethod
+    def _pad_and_stack_tensors(values):
+        shapes = [tuple(value.shape) for value in values]
+        if len(set(shapes)) == 1:
+            return torch.stack(values, dim=0)
+
+        if all(value.ndim == 1 for value in values):
+            max_len = max(value.shape[0] for value in values)
+            fill_value = False if values[0].dtype == torch.bool else 0
+            padded = []
+            for value in values:
+                out = torch.full(
+                    (max_len,),
+                    fill_value,
+                    dtype=value.dtype,
+                    device=value.device,
+                )
+                out[: value.shape[0]] = value
+                padded.append(out)
+            return torch.stack(padded, dim=0)
+
+        raise ValueError(f"Cannot batch tensors with different shapes: {shapes}")
+    def _infer_batch(self, observations, return_normalized=False):
+        if not isinstance(observations, (list, tuple)) or len(observations) == 0:
+            raise ValueError("batch observation must be a non-empty list")
+        applied = [self._prepare_model_input(obs) for obs in observations] # bsize, dict{key }
+        batch_observation = {}
+        for key in applied[0].keys():
+            values = [item[key] for item in applied]
+            if isinstance(values[0], torch.Tensor):
+                # Pad different 1d tokens to the max length: language, language mask
+                batch_observation[key] = self._pad_and_stack_tensors(values)
+            else:
+                batch_observation[key] = values
+
+        actions = self.vla.sample_actions_batch(
+            batch_observation,
+            self.use_bf16,
+            self.use_compile,
+            capture_time=False,
+            sample_compile_fn = self.sample_actions_fn,
+        )
+        
+        unnormalized_actions = self._unapply_batched_actions(applied, actions)
+        if return_normalized:
+            return unnormalized_actions, actions
+        return unnormalized_actions
+        
+    def infer(self, observation, center_crop=True, return_normalized=False):
+        """Generates an action with the VLA policy."""
+        # (If trained with image augmentations) Center crop image and then resize back up to original size.
+        # IMPORTANT: Let's say crop scale == 0.9. To get the new height and width (post-crop), multiply
+        #            the original height and width by sqrt(0.9) -- not 0.9!
+        if 'reset' in observation and observation['reset']:
+            self.reset(robo_name=observation['robo_name'], path_to_pi_model=observation['path_to_pi_model'] if 'path_to_pi_model' in observation else None)
+            return dict(action = None)
+
+        is_batch = 'batch' in observation
+        observations = observation['batch'] if is_batch else [observation]
+        if not self.chunk_ret and self.use_length <= 0:
+            raise ValueError(f"use_length must be > 0 when chunk_ret=False, got {self.use_length}")
+        should_forward = (
+            self.chunk_ret
+            or self.last_action_chunk is None
+            or (return_normalized and self.last_normalized_action_chunk is None)
+            or self.global_step % self.use_length == 0
+            or self.use_length == -1 
+        )
+
+        if should_forward:
+            if return_normalized:
+                unnormalized_actions, normalized_actions = self._infer_batch(
+                    observations,
+                    return_normalized=True,
+                )
+            else:
+                unnormalized_actions = self._infer_batch(observations)
+                normalized_actions = None
+            if self.use_length > 0:
+                for output_key in unnormalized_actions.keys():
+                    assert self.use_length <= unnormalized_actions[output_key].shape[1]
+                    unnormalized_actions[output_key] = unnormalized_actions[output_key][:, :self.use_length]
+                if normalized_actions is not None:
+                    assert self.use_length <= normalized_actions.shape[1]
+                    normalized_actions = normalized_actions[:, :self.use_length]
+            
+            self.last_action_chunk = unnormalized_actions  # always (B, chunk, dim)
+            self.last_normalized_action_chunk = normalized_actions
+
+        if self.chunk_ret:
+            action = self.last_action_chunk               # (B, chunk, dim)
+            normalized_action = self.last_normalized_action_chunk
+        else:
+            step_idx = self.global_step % self.use_length
+            action = {}
+            for action_key in self.last_action_chunk.keys():
+                action[action_key] = self.last_action_chunk[action_key][:, step_idx]
+            normalized_action = (
+                self.last_normalized_action_chunk[:, step_idx]
+                if self.last_normalized_action_chunk is not None
+                else None
+            )
+
+        if not is_batch:
+            for action_key in action:
+                action[action_key] = action[action_key][0]
+            if normalized_action is not None:
+                normalized_action = normalized_action[0]
+
+        result = action
+        if return_normalized:
+            result = dict(result)
+            result["_normalized_actions"] = normalized_action
+
+        self.global_step += 1
+        
+        return result
+
+def str2bool(v):
+    if isinstance(v, bool):
+        return v
+    if v.lower() in ("yes", "true", "t", "1"):
+        return True
+    elif v.lower() in ("no", "false", "f", "0"):
+        return False
+    raise argparse.ArgumentTypeError("Boolean value expected.")
+
+import argparse
+try:
+    from .websocket_policy_server import WebsocketPolicyServer
+except ImportError:
+    from deploy.websocket_policy_server import WebsocketPolicyServer
+
+def main():
+    parser = argparse.ArgumentParser(description="Launch the Qwen3VL LingbotVlaV2 WebSocket policy server")
+
+    parser.add_argument(
+        "--model_path",
+        type=str,
+    )
+
+    parser.add_argument(
+        "--use_length",
+        type=int,
+        default=50,
+        help="chunk length to use"
+    )
+
+    parser.add_argument(
+        "--chunk_ret",
+        type=str2bool,
+        default=True,
+        help="chunk length to use"
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8006,
+        help="WebSocket server port"
+    )
+
+    parser.add_argument(
+        "--use_bf16",
+        type=str2bool,
+        default=True,
+    )
+
+    parser.add_argument(
+        "--use_fp32",
+        type=str2bool,
+        default=False,
+    )
+
+    parser.add_argument(
+        "--use_compile",
+        type=str2bool,
+        default=True,
+    )
+
+    args = parser.parse_args()
+
+    model = LingbotVLAv2Server(
+        args.model_path,
+        use_length=args.use_length,
+        chunk_ret=args.chunk_ret,
+        use_bf16=args.use_bf16,
+        use_fp32=args.use_fp32,
+        use_compile=args.use_compile,
+    )
+    model_server = WebsocketPolicyServer(model, port=args.port)
+    model_server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()