Publish direct-use target-aware GWAM training view v1

README.md

@@ -40,6 +40,8 @@ This is principally a loader/derived-view update over data already stored on the
 
 The key representation rule is one canonical physical graph per frame. Right, left, and wrist are camera-indexed observation records on the same persistent physical nodes; they are not three independent graphs. See the [full illustration](gwam_active13_target_physical_v2_0_1_20260731/guides/ONE_GRAPH_THREE_VIEWS.svg).
 
+> **Direct-use target-aware GWAM training:** use [`gwam_active13_gwam_training_v1_20260731/`](gwam_active13_gwam_training_v1_20260731/README.md). Its executable loader joins all 2,699 resolved episodes into 702,094 legal temporal windows and returns a backward-compatible 344-D rich node tensor, typed three-view records, actions, future graph targets, and target bits. The graph ZIPs do **not** contain original RGB videos; the loader can join separately obtained RoboCasa/LeRobot videos by exact `source_frame`. The same guide provides the full `extract_final_graph()` current-frame evaluation path and aligned RGB outputs.
+
 There is one narrowly scoped value overlay: for 146 selected episodes, only `graph/visual_features_sparse.npz::type_clip32` differs from the canonical ZIP. The normative loader verifies the canonical ZIP, the canonical NPZ member, and the overlay blob before applying that change to a temporary extraction. It never mutates the downloaded ZIP.
 
 Use these files as the source of truth:
@@ -80,6 +82,7 @@ The excluded episode repeatedly failed RoboCasa environment initialization. It h
 ```text
 canonical Active-13 tag:    gwam-13task-data-v4
 target-aware docs tag:      gwam-target-v2.0.1-docs-v1
+target-aware training tag:  gwam-target-v2.0.1-training-v1
 task names:                 13
 split/task collections:     16
 selected episode ZIPs:      4,937
@@ -112,14 +115,14 @@ Three names occur independently in both `target` and `pretrain`: `PickPlaceCount
 
 ## Download the active 13 tasks
 
-Use the immutable `gwam-target-v2.0.1-docs-v1` tag for the canonical Active-13 files plus the target-aware sidecar and this student guide. It contains the same canonical episode bytes bound by `gwam-13task-data-v4`; the newer tag adds versioned target metadata and documentation. Download every matching source tier instead of assuming a task exists in only one tier.
+Use the immutable `gwam-target-v2.0.1-training-v1` tag for canonical Active-13 files, the target-aware sidecar, the direct training view, and student guides. It contains the same canonical episode bytes bound by `gwam-13task-data-v4`; the newer tag adds versioned target metadata, executable joins, and documentation. Download every matching source tier instead of assuming a task exists in only one tier.
 
 ### Python
 
 ```python
 from huggingface_hub import snapshot_download
 
-REVISION = "gwam-target-v2.0.1-docs-v1"
+REVISION = "gwam-target-v2.0.1-training-v1"
 TASKS = [
     "CoffeeSetupMug",
     "OpenDrawer",
@@ -149,6 +152,7 @@ patterns += [
     "gwam_13task_active_v1_20260728/**",
     "training_splits/active13_gnn_v1/**",
     "gwam_active13_target_physical_v2_0_1_20260731/**",
+    "gwam_active13_gwam_training_v1_20260731/**",
     "loaders/**",
     "tests/test_gwam_full_graph_window.py",
 ]
@@ -168,7 +172,7 @@ snapshot_download(
 ```bash
 hf download ChangChrisLiu/GWAM_Data \
   --repo-type dataset \
-  --revision gwam-target-v2.0.1-docs-v1 \
+  --revision gwam-target-v2.0.1-training-v1 \
   --include 'gwam_v12_sparse_v2/episodes/*/CoffeeSetupMug/*.zip' \
   --include 'gwam_v12_sparse_v2/episodes/*/OpenDrawer/*.zip' \
   --include 'gwam_v12_sparse_v2/episodes/*/PickPlaceCabinetToCounter/*.zip' \
@@ -189,6 +193,7 @@ hf download ChangChrisLiu/GWAM_Data \
   --include 'gwam_13task_active_v1_20260728/**' \
   --include 'training_splits/active13_gnn_v1/**' \
   --include 'gwam_active13_target_physical_v2_0_1_20260731/**' \
+  --include 'gwam_active13_gwam_training_v1_20260731/**' \
   --include 'loaders/**' \
   --include 'tests/test_gwam_full_graph_window.py' \
   --include 'README.md' \

SCHEMA.md

@@ -378,3 +378,20 @@ The current graph profile is exactly `active13_target_physical_v2` with relation
 
 The static census is exactly 2,699/2,699 `RESOLVED`; the independent reset/static audit is 500 comparisons with 0 disagreements. Both operate on frozen outer-train/static metadata only. Validation/test dynamic data and all trajectory/outcome sources remain outside this release view. See the prefix `SCHEMA.md` for the executable file and receipt contract.
 <!-- END GRAPHPACKET_SLIM_V2_0_1_SIDECAR_SCHEMA -->
+
+<!-- BEGIN ACTIVE13_DIRECT_GWAM_TRAINING_V1 -->
+## Direct-use target-aware GWAM training view
+
+The additive namespace `gwam_active13_gwam_training_v1_20260731/` is a lazy executable join over 2,699 immutable canonical episode ZIPs and their v2.0.1 target receipts. It enumerates 702,094 legal `L=8,H=8,stride=1` windows and exposes the inherited typed temporal graph plus `history.gwam_node_features float32[L,N,344]`:
+
+```text
+20 physical/state + 10 family one-hot + 256 SAM2 valid-view mean
++ 32 type_clip32 + 24 three-view evidence + 2 target fields = 344
+```
+
+The original non-averaged `sam2_visual[L,N,3,256]`, `view_evidence[L,N,3,8]`, and masks remain available. The convenience 344-D field preserves the prior 342-D full-final-graph interface and appends `is_task_target,task_target_valid`.
+
+Original RGB/video is **not** stored in canonical graph ZIPs. Optional joint graph+video loading requires separately obtained RoboCasa/LeRobot videos and joins them using `source_tier/task/episode_id` plus `graph/frames.jsonl::source_frame`.
+
+For online evaluation, root `RealtimeGWAMGraphExtractor.extract_final_graph()` constructs the current full 342-D physical/visual graph and returns aligned right/left/wrist RGB. A target helper appends only a complete pre-action task/reset target-slot set, producing `x_target_aware[N,344]`. `extract_current_graph()` remains Phase-1/debug only.
+<!-- END ACTIVE13_DIRECT_GWAM_TRAINING_V1 -->

gwam_active13_gwam_training_v1_20260731/DATASET_SUMMARY.json

@@ -0,0 +1,42 @@
+{
+  "action_width": 12,
+  "artifact_type": "GWAMActive13DirectTrainingViewSummary",
+  "canonical_zip_bytes_referenced": 20339307035,
+  "episode_count": 2699,
+  "graph_payload_location": "referenced canonical_zip_path files already in ChangChrisLiu/GWAM_Data",
+  "history_length": 8,
+  "horizon": 8,
+  "index_sha256": "757b3320ba991a2ece0c0a2a431cfde84db24e6837871855072b28663d89859e",
+  "model_split": "train",
+  "rgb_in_graph_zip": false,
+  "rgb_requirement": "Joint graph+video training requires separately obtained source RoboCasa/LeRobot RGB videos joined by source_tier/task/episode_id and graph/frames.jsonl::source_frame.",
+  "source_group_counts": {
+    "CoffeeSetupMug": 8,
+    "OpenDrawer": 64,
+    "PickPlaceCabinetToCounter": 85,
+    "PickPlaceCounterToCabinet": 134,
+    "PickPlaceCounterToMicrowave": 86,
+    "PickPlaceCounterToSink": 83,
+    "PickPlaceCounterToStove": 93,
+    "PickPlaceMicrowaveToCounter": 87,
+    "PickPlaceSinkToCounter": 101,
+    "PickPlaceStoveToCounter": 87
+  },
+  "status": "LAZY_DERIVED_VIEW",
+  "target_payload_location": "referenced v2.0.1 sidecar receipts already in ChangChrisLiu/GWAM_Data",
+  "task_counts": {
+    "CoffeeSetupMug": 392,
+    "OpenDrawer": 409,
+    "PickPlaceCabinetToCounter": 85,
+    "PickPlaceCounterToCabinet": 488,
+    "PickPlaceCounterToMicrowave": 88,
+    "PickPlaceCounterToSink": 86,
+    "PickPlaceCounterToStove": 487,
+    "PickPlaceMicrowaveToCounter": 90,
+    "PickPlaceSinkToCounter": 487,
+    "PickPlaceStoveToCounter": 87
+  },
+  "version": "1.0.0",
+  "view_count": 3,
+  "window_count_L8_H8_stride1": 702094
+}

gwam_active13_gwam_training_v1_20260731/README.md

@@ -0,0 +1,385 @@
+# Active-13 direct-use target-aware GWAM training view v1
+
+Status: **published-data join package prepared for direct graph training**.
+
+This prefix makes the current target-aware graph release usable in a training loop without requiring students to manually join three manifests. It does not duplicate or rewrite the 20.34 GB of canonical graph ZIPs already stored in `ChangChrisLiu/GWAM_Data`.
+
+## Direct answer
+
+### Can a student directly train with the graph data?
+
+**Yes.** Download this view and instantiate `TargetAwareGWAMTrainingDataset`. It exposes:
+
+```text
+2,699 target-resolved training episodes
+702,094 legal L=8, H=8, stride-1 windows
+canonical physical graph history
+three-view geometry, masks, and SAM2 records
+typed/ragged edges
+8 future actions
+8 future physical/contact targets
+task target bits joined to the same physical nodes
+```
+
+### Are RGB/video frames inside the graph ZIPs?
+
+**No.** The canonical graph ZIPs include exact masks, three-view geometry, and extracted SAM2/CLIP features, but they do not contain original RGB videos.
+
+Therefore:
+
+| Training use | Immediately available after this graph download? |
+|---|---|
+| Graph-only GNN / graph dynamics | Yes |
+| GWAM using stored graph features as its observation | Yes |
+| Joint RGB/video + graph GWAM | Graph side yes; original RoboCasa/LeRobot RGB must be obtained separately |
+| Live RoboCasa evaluation | Yes, using the public realtime extractor plus a local RoboCasa installation |
+
+When a local source RGB root is supplied, the unified loader can decode the exact aligned history/future video frames using:
+
+```text
+(source_tier, task, episode_id, graph/frames.jsonl::source_frame)
+```
+
+It never guesses frame alignment.
+
+## What is in this prefix?
+
+```text
+TRAINING_EPISODES.jsonl
+DATASET_SUMMARY.json
+loader/target_aware_gwam_training_dataset.py
+download_training_data.py
+examples/current_frame_target_aware_eval.py
+examples/VALIDATED_OUTPUT.json
+README.md
+SCHEMA.md
+RGB_AND_REALTIME.md
+```
+
+`TRAINING_EPISODES.jsonl` references existing immutable files:
+
+```text
+canonical graph ZIP:
+  gwam_v12_sparse_v2/episodes/<tier>/<task>/episode_xxxxxx.zip
+
+target receipt:
+  gwam_active13_target_physical_v2_0_1_20260731/sidecars/target_resolution/...
+
+root temporal loader:
+  loaders/gwam_full_graph_window.py
+```
+
+## 1. Download all directly usable graph-training data
+
+Install the Hub client:
+
+```bash
+pip install -U huggingface_hub
+```
+
+Download all 2,699 referenced canonical graph ZIPs, sidecars, loaders, realtime code, and bundled SAM2/CLIP weights:
+
+```bash
+python gwam_active13_gwam_training_v1_20260731/download_training_data.py \
+  --local-dir ./GWAM_Data_target_training
+```
+
+The canonical ZIP payload referenced by this view is 20,339,307,035 bytes before Hub/cache overhead. Original RGB videos are not downloaded because they are not in this HF repository.
+
+Immutable revision:
+
+```text
+gwam-target-v2.0.1-training-v1
+```
+
+## 2. Load one directly usable training window
+
+```python
+import sys
+from pathlib import Path
+
+root = Path("./GWAM_Data_target_training")
+prefix = root / "gwam_active13_gwam_training_v1_20260731"
+sys.path.insert(0, str(prefix / "loader"))
+
+from target_aware_gwam_training_dataset import TargetAwareGWAMTrainingDataset
+
+with TargetAwareGWAMTrainingDataset(
+    root,
+    as_torch=False,
+    strict=True,
+    verify_zip_on_first_open=True,
+    validate_all_target_receipts=True,
+    rgb_mode="none",
+) as dataset:
+    sample = dataset[0]
+
+print(len(dataset))
+# 702094
+
+print(sample["history"]["gwam_node_features"].shape)
+# [8,N,344]
+
+print(sample["history"]["view_evidence"].shape)
+# [8,N,3,8]
+
+print(sample["history"]["sam2_visual"].shape)
+# [8,N,3,256]
+
+print(sample["future_action"].shape)
+# [8,12]
+
+print(sample["targets"]["contact_pair_event"].shape)
+# [8,Q], Q=N*(N-1)/2
+```
+
+The returned sample retains every typed field from `GWAMFullGraphEpisode`; `gwam_node_features` is an additional convenience tensor, not a replacement for the typed contract.
+
+## 3. Ready-to-use rich node dimension
+
+Per history frame and active node:
+
+```text
+20  physical state and visibility
+10  family one-hot
+256 view-valid mean of the three camera-indexed SAM2 records
+32  type_clip32
+24  right/left/wrist view evidence: 3 × 8
+1   is_task_target
+1   task_target_valid
+-----------------------------------
+344 total dimensions
+```
+
+The first 342 dimensions match the prior full-final-graph training representation. The final two dimensions add the target-aware contract.
+
+The loader still returns the non-averaged source records:
+
+```text
+sam2_visual   [L,N,3,256]
+view_evidence [L,N,3,8]
+mask_raster   [L,N,3,1,16,16]
+```
+
+Use those typed records for a view-aware architecture. The 344-D convenience tensor uses the previous release's view-valid SAM2 mean only for backward compatibility with the established GWAM interface.
+
+## 4. PyTorch batch
+
+```python
+from torch.utils.data import DataLoader
+
+with TargetAwareGWAMTrainingDataset(root, as_torch=False) as dataset:
+    loader = DataLoader(
+        dataset,
+        batch_size=2,
+        shuffle=True,
+        num_workers=0,  # raise after local storage/cache profiling
+        collate_fn=dataset.collate_torch,
+    )
+    batch = next(iter(loader))
+
+print(batch["history"]["gwam_node_features"].shape)
+# [B,8,N_batch_max,344]
+
+print(batch["history"]["node_valid"].shape)
+# [B,8,N_batch_max]
+
+print(batch["future_action"].shape)
+# [B,8,12]
+```
+
+The collator pads nodes only to the maximum `N` in that batch, offsets ragged edges, pads full-pair targets, preserves masks, and keeps metadata separate.
+
+## 5. Joint graph + source RGB/video training
+
+The graph release deliberately does not pretend RGB is present. To decode source video, provide the original RoboCasa dataset root:
+
+```python
+with TargetAwareGWAMTrainingDataset(
+    root,
+    rgb_root="/path/to/robocasa_datasets/v1.0",
+    rgb_mode="history_future",
+) as dataset:
+    sample = dataset[0]
+
+print(sample["rgb"]["frames"].shape)
+# [16,3,256,256,3] = history+future, right/left/wrist, uint8 RGB
+
+print(sample["rgb"]["source_frame_indices"])
+```
+
+Expected source layout follows RoboCasa/LeRobot:
+
+```text
+<rgb_root>/<tier>/.../<task>/.../lerobot/videos/chunk-*/
+  observation.images.robot0_agentview_right/episode_xxxxxx.mp4
+  observation.images.robot0_agentview_left/episode_xxxxxx.mp4
+  observation.images.robot0_eye_in_hand/episode_xxxxxx.mp4
+```
+
+The loader requires exactly one video match per episode/camera and fails closed on missing or ambiguous paths.
+
+If your WAM uses source RGB as the prediction target:
+
+```text
+history RGB + history graph + actions -> predicted future RGB/video
+                                  + -> predicted future graph (optional auxiliary)
+```
+
+Do not feed future RGB, future graph, success, reward, completion, or progress into the condition.
+
+## 6. Generate the full graph from the current frame for evaluation
+
+The official current-frame API is `extract_final_graph()`. The official current-frame path is the same full Phase-1 + Phase-2 route used by the prior release:
+
+```text
+current simulator qpos/qvel/contact
++ current right/left/wrist RGB
++ current segmentation and visible masks
++ Phase-1 physical graph construction
++ Phase-2 SAM2 masked pooling
++ CLIP type features
+= current full graph x[N,342] + aligned RGB[3,256,256,3]
+```
+
+Install/setup the realtime environment from the downloaded repository:
+
+```bash
+bash scripts/setup_realtime_final_graph_env.sh
+```
+
+Generate one current-frame physical/visual graph:
+
+```bash
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python examples/realtime_env_graph_eval_loop.py \
+  --task OpenDrawer \
+  --robots PandaOmron \
+  --steps 1 \
+  --visual-backend sam2 \
+  --device cuda \
+  --save-dir ./eval_snapshot \
+  --json-output ./eval_snapshot/summary.json
+```
+
+Model-facing Python API:
+
+```python
+from realtime.gwam_realtime_env_graph import (
+    RealtimeGWAMGraphExtractor,
+    Sam2ClipRealtimeFeatureBackend,
+)
+
+extractor = RealtimeGWAMGraphExtractor(env)
+backend = Sam2ClipRealtimeFeatureBackend(device="cuda")
+
+# Call only on the current state that the policy is allowed to observe.
+snapshot = extractor.extract_final_graph(
+    visual_backend=backend,
+    include_masks=True,
+)
+
+graph = snapshot["gnn_graph"]
+print(graph["x"].shape)             # [N,342]
+print(graph["edge_index"].shape)    # [2,E]
+print(graph["edge_attr"].shape)     # [E,8]
+print(snapshot["rgb_frames"][0].shape)  # [256,256,3]
+```
+
+`extract_current_graph()` is only a 33-D Phase-1 debugging path. Do not use it as the final GWAM evaluation input.
+
+### Add current task-target fields
+
+The physical/visual extractor cannot safely guess task targets from outcomes. Supply the complete target storage slots from the task/reset specification available before action selection:
+
+```python
+from target_aware_gwam_training_dataset import (
+    attach_known_task_targets_to_realtime_graph,
+)
+
+snapshot = attach_known_task_targets_to_realtime_graph(
+    snapshot,
+    target_storage_slots=[1],
+    provenance="RoboCasa reset task specification",
+)
+
+print(snapshot["gnn_graph"]["x_target_aware"].shape)
+# [N,344]
+```
+
+Or use the direct runner:
+
+```bash
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python gwam_active13_gwam_training_v1_20260731/examples/current_frame_target_aware_eval.py \
+  --task PickPlaceCabinetToCounter \
+  --robots PandaOmron \
+  --device cuda \
+  --target-node-id obj \
+  --target-provenance 'RoboCasa reset task specification PickPlaceCabinetToCounter' \
+  --save-dir ./current_target_graph
+```
+
+For the nine object-manipulation task rules in this release, `obj` is the authored target node ID. OpenDrawer has a reset-selected drawer root plus its operative slide component; obtain that complete pair from the current reset inventory/task specification and pass repeated `--target-node-id` or `--target-slot` arguments. Never hard-code storage slots across resets. The script fails if a supplied node/slot is absent and never infers targets from contact, action, success, reward, or future state. Live target provenance is marked `CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED`; bind it to your evaluation harness's own reset/task receipt. Offline training receipts remain content-addressed.
+
+Saved evaluation snapshot:
+
+```text
+eval_snapshot/graph/node_state.npz
+eval_snapshot/graph/view_evidence.npz
+eval_snapshot/graph/visible_masks_rle.jsonl.gz
+eval_snapshot/graph/visual_features_sparse.npz
+eval_snapshot/rgb/view_0_robot0_agentview_right.npy
+eval_snapshot/rgb/view_1_robot0_agentview_left.npy
+eval_snapshot/rgb/view_2_robot0_eye_in_hand.npy
+eval_snapshot/rgb_manifest.json
+current_target_graph/target_aware_graph.npz
+current_target_graph/target_aware_summary.json
+```
+
+## 7. Realtime verification
+
+Graph/RGB alignment with deterministic visual backend:
+
+```bash
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python scripts/verify_rgb_graph_alignment.py
+```
+
+Full real SAM2/CLIP graph:
+
+```bash
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python scripts/verify_realtime_final_graph.py \
+  --visual-backend sam2 \
+  --device cuda
+```
+
+Required invariants:
+
+```text
+final_graph = true
+D_node = 342 before target fields
+D_node_target_aware = 344 after target fields
+D_edge = 8
+rgb_view_count = 3
+rgb shape per view = [256,256,3]
+current extraction does not advance simulator state
+```
+
+## 8. Causal boundary
+
+```text
+history: G[s:s+7]
+actions: u[s+7:s+14]
+targets: G[s+8:s+15]
+```
+
+- One physical graph per frame.
+- Right/left/wrist are three observations of the same nodes.
+- Actions remain separate from graph fields.
+- Target bits come only from pre-action task/reset information.
+- Future graph and future RGB are supervision only.
+- No success/completion/progress/reward input.
+
+See [`RGB_AND_REALTIME.md`](RGB_AND_REALTIME.md) for source-video pairing and evaluation details and [`SCHEMA.md`](SCHEMA.md) for the complete machine-facing contract.

gwam_active13_gwam_training_v1_20260731/RGB_AND_REALTIME.md

@@ -0,0 +1,215 @@
+# RGB availability and current-frame evaluation graph generation
+
+## RGB availability
+
+The graph ZIPs do **not** contain original video or RGB images.
+
+They contain derived observation evidence:
+
+```text
+three-view visibility/centroid/area/bbox
+lossless visible masks as RLE
+three-view sparse SAM2 features
+CLIP type features
+actions and physical graph state
+```
+
+Why the distinction matters:
+
+```text
+stored SAM2 feature != original RGB frame
+stored RLE mask      != original RGB frame
+```
+
+Graph-only and graph-feature-conditioned training can use this HF repository directly. Pixel/video prediction requires the separately distributed source RoboCasa/LeRobot videos.
+
+## Offline RGB join
+
+For each indexed training episode, use:
+
+```text
+source_tier
+task
+episode_id
+graph/frames.jsonl::source_frame
+```
+
+Canonical camera order:
+
+```text
+0 robot0_agentview_right
+1 robot0_agentview_left
+2 robot0_eye_in_hand
+```
+
+Typical source layout:
+
+```text
+<rgb_root>/<tier>/.../<task>/<collection>/lerobot/videos/chunk-000/
+  observation.images.robot0_agentview_right/episode_xxxxxx.mp4
+  observation.images.robot0_agentview_left/episode_xxxxxx.mp4
+  observation.images.robot0_eye_in_hand/episode_xxxxxx.mp4
+```
+
+The public unified loader searches only under the indexed tier/task and requires exactly one matching file per camera. It decodes the exact source-frame indices and returns RGB in right/left/wrist order.
+
+## Current-frame graph generation
+
+At an allowed current state `t`:
+
+```text
+simulator current state
++ current contacts
++ current three-camera segmentation/masks
++ current three-camera RGB
++ current SAM2 masked pooling
++ current CLIP type features
+-> one current full physical/visual graph
+```
+
+There are not three graphs. The three camera panels are observations attached to the same physical node inventory.
+
+### Environment setup
+
+The HF repository bundles:
+
+```text
+models/sam2/checkpoints/sam2.1_hiera_base_plus.pt
+models/clip/ViT-B-32.pt
+models/MODEL_MANIFEST.json
+```
+
+It does not redistribute RoboCasa/MuJoCo assets. Install those locally, then run:
+
+```bash
+bash scripts/setup_realtime_final_graph_env.sh
+```
+
+### Generate and save one current frame
+
+```bash
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python examples/realtime_env_graph_eval_loop.py \
+  --task OpenDrawer \
+  --robots PandaOmron \
+  --steps 1 \
+  --visual-backend sam2 \
+  --device cuda \
+  --save-dir ./eval_snapshot \
+  --json-output ./eval_snapshot/summary.json
+```
+
+This uses `extract_final_graph()`, not the Phase-1 debug API.
+
+### Python API
+
+```python
+from realtime.gwam_realtime_env_graph import (
+    RealtimeGWAMGraphExtractor,
+    Sam2ClipRealtimeFeatureBackend,
+)
+
+extractor = RealtimeGWAMGraphExtractor(env)
+visual = Sam2ClipRealtimeFeatureBackend(device="cuda")
+
+snapshot = extractor.extract_final_graph(
+    visual_backend=visual,
+    include_masks=True,
+)
+
+x = snapshot["gnn_graph"]["x"]
+edge_index = snapshot["gnn_graph"]["edge_index"]
+edge_attr = snapshot["gnn_graph"]["edge_attr"]
+rgb = snapshot["rgb_frames"]
+
+assert x.shape[1] == 342
+assert edge_index.shape[0] == 2
+assert edge_attr.shape[1] == 8
+assert len(rgb) == 3
+assert all(frame.shape == (256, 256, 3) for frame in rgb.values())
+```
+
+### Inspect storage slots before attaching task targets
+
+```python
+for storage_slot, node in enumerate(snapshot["graph_static"]["nodes"]):
+    print(storage_slot, node["node_id"], node["family"], node.get("articulated"))
+```
+
+Obtain the complete target list from the current task/reset specification. Then append target fields:
+
+```python
+from target_aware_gwam_training_dataset import (
+    attach_known_task_targets_to_realtime_graph,
+)
+
+snapshot = attach_known_task_targets_to_realtime_graph(
+    snapshot,
+    target_storage_slots=complete_target_slots,
+    provenance="RoboCasa reset task specification",
+)
+
+assert snapshot["gnn_graph"]["x_target_aware"].shape[1] == 344
+```
+
+This live helper is deliberately labeled `CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED`: it validates shape, slot presence, completeness assertions, and obvious forbidden provenance labels, but it cannot cryptographically authenticate an arbitrary live environment's task/reset object. Production evaluation must bind the supplied node IDs/slots to its own reset/task receipt. Offline training receipts remain content-addressed and source-bound.
+
+For the nine object manipulation rules in this release, the authored target is the unique reset object named `obj`. For OpenDrawer, the complete authored target consists of the reset-selected drawer fixture root and its operative articulated drawer-slide component. Resolve those from the current reset inventory/task specification; do not hard-code slot numbers across resets.
+
+### Save contract
+
+`save_realtime_graph_snapshot()` writes:
+
+```text
+snapshot/graph/node_state.npz
+snapshot/graph/view_evidence.npz
+snapshot/graph/visible_masks_rle.jsonl.gz
+snapshot/graph/visual_features_sparse.npz
+snapshot/graph/graph_static.json
+snapshot/graph/dynamic_edges.jsonl
+snapshot/rgb/view_0_robot0_agentview_right.npy
+snapshot/rgb/view_1_robot0_agentview_left.npy
+snapshot/rgb/view_2_robot0_eye_in_hand.npy
+snapshot/rgb_manifest.json
+```
+
+The target-aware runner additionally writes:
+
+```text
+target_aware_graph.npz
+target_aware_summary.json
+```
+
+## Evaluation timing rule
+
+Allowed:
+
+```text
+reset/step reaches state t
+extract current graph G_t and current RGB I_t
+policy/model chooses action a_t
+step environment to t+1
+```
+
+Forbidden for default causal evaluation:
+
+```text
+look at G_(t+1), I_(t+1), contact_(t+1), success, reward, or completion
+then condition the prediction/action at t
+```
+
+Future-state extraction is permitted only in an explicitly labeled oracle/teacher-forced experiment.
+
+## Verification
+
+```bash
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python scripts/verify_rgb_graph_alignment.py
+
+MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
+python scripts/verify_realtime_final_graph.py \
+  --visual-backend sam2 \
+  --device cuda
+```
+
+The first command verifies current-state immutability and exact RGB/mask/feature alignment. The second verifies the real full SAM2/CLIP path and required 342-D/8-D graph dimensions.

gwam_active13_gwam_training_v1_20260731/SCHEMA.md

@@ -0,0 +1,192 @@
+# Active-13 direct-use target-aware GWAM training schema v1
+
+## Release identity
+
+```text
+prefix: gwam_active13_gwam_training_v1_20260731/
+schema: gwam.active13.gwam_training_episode.v1
+status: LAZY_DERIVED_VIEW
+canonical episode rows: 2,699
+legal L=8/H=8/stride-1 windows: 702,094
+canonical ZIP bytes referenced: 20,339,307,035
+original RGB stored in graph ZIPs: false
+```
+
+This package is a content-addressed join and executable loader. It does not duplicate or mutate canonical episode ZIPs or target receipts.
+
+## Training index row
+
+Each line in `TRAINING_EPISODES.jsonl` contains:
+
+```text
+schema
+universe_index
+episode_key
+source_tier
+task
+episode_id
+source_group_id
+model_split = train
+canonical_zip_path
+canonical_zip_sha256
+canonical_zip_size
+type_clip32_overlay_applied
+frames_processed
+history_length = 8
+horizon = 8
+valid_start_count
+target_receipt_path
+target_receipt_sha256
+target_cardinality
+resolution_status = RESOLVED
+rgb_in_graph_zip = false
+rgb_join_key
+```
+
+`valid_start_count = frames_processed - 8 - 8 + 1`. The index does not create windows using future activity or outcomes.
+
+## Sample temporal contract
+
+For zero-based start `s`:
+
+```text
+history graph frames: s ... s+7
+anchor graph frame:   s+7
+action frames:        s+7 ... s+14
+future target frames: s+8 ... s+15
+```
+
+The action at frame `t` is the logged condition for transition `G_t -> G_(t+1)`.
+
+## Existing typed fields retained
+
+The unified loader delegates source parsing and strict integrity checks to root `loaders/gwam_full_graph_window.py`. It retains:
+
+```text
+history.static_flags          float32[L,N,2]
+history.kinematic_state       float32[L,N,15]
+history.state_visibility      float32[L,N,3]
+history.state_plus_visibility float32[L,N,20]
+history.node_valid            bool[L,N]
+history.family_id             int64[N]
+history.type_clip32           float32[N,32]
+history.type_clip_valid       bool[N]
+history.view_evidence         float32[L,N,3,8]
+history.sam2_visual           float32[L,N,3,256]
+history.sam2_valid            bool[L,N,3]
+history.sam2_failed           bool[L,N,3]
+history.mask_raster           float32[L,N,3,1,16,16]
+history.mask_valid            bool[L,N,3]
+history.edge_index            list[L] int64[2,E_t]
+history.edge_attr             list[L] float32[E_t,8]
+
+future_action                 float32[8,12]
+future_action_valid           bool[8]
+
+targets.kinematic_state       float32[8,N,15]
+targets.view_evidence         float32[8,N,3,8]
+targets.contact_pair_index    int64[2,Q]
+targets.contact_pair_event    int64[8,Q]
+targets.contact_pair_valid    bool[8,Q]
+```
+
+`N` is the active node count. `Q=N*(N-1)/2` is the full unique unordered pair domain.
+
+## Direct rich GWAM convenience tensor
+
+```text
+history.gwam_node_features float32[L,N,344]
+```
+
+| Columns | Width | Source |
+|---:|---:|---|
+| `0:20` | 20 | `state_plus_visibility` |
+| `20:30` | 10 | one-hot `family_id` |
+| `30:286` | 256 | view-valid mean of `sam2_visual` across the explicit camera axis |
+| `286:318` | 32 | validity-gated `type_clip32` |
+| `318:342` | 24 | flattened right/left/wrist `view_evidence` |
+| `342:343` | 1 | `is_task_target` |
+| `343:344` | 1 | `task_target_valid` |
+
+The loader also retains non-averaged `[L,N,3,...]` records. The SAM2 mean exists only for compatibility with the prior 342-D GWAM interface.
+
+Target invariants:
+
+```text
+is_task_target <= task_target_valid <= anchor node_valid
+```
+
+Unknown target is `(0,0)`, confirmed non-target is `(0,1)`, and confirmed target is `(1,1)`.
+
+## Batched contract
+
+`dataset.collate(samples, as_torch=True)` returns batch-max node padding:
+
+```text
+history.gwam_node_features [B,8,N_batch_max,344]
+history.node_valid         [B,8,N_batch_max]
+history.is_task_target     [B,N_batch_max]
+history.task_target_valid  [B,N_batch_max]
+future_action              [B,8,12]
+```
+
+Ragged edges receive batch offsets and batch/time ids through the inherited canonical collator. Full-pair targets receive explicit padding and validity.
+
+## RGB contract
+
+Canonical graph ZIPs do not contain RGB/video bytes.
+
+When `rgb_mode=history` or `history_future`, a separately supplied `rgb_root` is mandatory. The loader reads exact frame alignment from `graph/frames.jsonl::source_frame`, requires one source video per camera, and returns:
+
+```text
+rgb.frames                 uint8[T_rgb,3,256,256,3]
+rgb.graph_frame_indices    int64[T_rgb]
+rgb.source_frame_indices   int64[T_rgb]
+rgb.cameras                [right,left,wrist]
+rgb.stored_in_graph_zip    false
+```
+
+`T_rgb=8` for history and `T_rgb=16` for history+future.
+
+## Current-frame online evaluation
+
+Root `realtime/gwam_realtime_env_graph.py::extract_final_graph()` returns:
+
+```text
+gnn_graph.x            float32[N,342]
+gnn_graph.edge_index   int64[2,E]
+gnn_graph.edge_attr    float32[E,8]
+rgb_frames[v]          uint8[256,256,3], v=0,1,2
+rgb_frame_cameras      ordered camera names
+visual_features_sparse current masked SAM2 rows
+graph_static           current persistent inventory/prior edges
+rle_masks              current exact visible masks
+```
+
+The target helper appends only pre-action task/reset target fields:
+
+```text
+gnn_graph.x_target_aware     float32[N,344]
+gnn_graph.is_task_target     bool[N]
+gnn_graph.task_target_valid  bool[N]
+```
+
+It requires a complete sorted unique target storage-slot list and nonempty provenance. It fails on absent slots and rejects provenance strings naming future/success/reward/outcome sources.
+
+Live target metadata is marked `CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED`; the helper does not claim cryptographic authentication of arbitrary environment reset objects. Evaluation harnesses must bind this assertion to their own task/reset receipt.
+
+`extract_current_graph()` is Phase-1/debug only and is not the final GWAM graph.
+
+## Causal exclusions
+
+Model inputs must exclude:
+
+```text
+future graph
+future RGB
+future contacts/geometry
+success/reward/termination
+finished/completed/progress
+correct-next-action labels
+outcome-derived target identity
+```

gwam_active13_gwam_training_v1_20260731/download_training_data.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Download the complete graph-only target-aware GWAM training view.
+
+This intentionally does not claim to download original RGB videos: they are not
+stored in GWAM_Data. The script downloads all 2,699 referenced canonical graph
+ZIPs, the target sidecar, unified loader, root temporal loader, and realtime
+evaluation code/weights.
+"""
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+from pathlib import Path
+
+REPO = "ChangChrisLiu/GWAM_Data"
+REVISION = "gwam-target-v2.0.1-training-v1"
+PREFIX = "gwam_active13_gwam_training_v1_20260731"
+TARGET_PREFIX = "gwam_active13_target_physical_v2_0_1_20260731"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--local-dir", type=Path, required=True)
+    parser.add_argument("--revision", default=REVISION)
+    parser.add_argument(
+        "--no-realtime",
+        action="store_true",
+        help="Skip online current-frame extraction code and bundled feature weights",
+    )
+    args = parser.parse_args()
+    args.local_dir.mkdir(parents=True, exist_ok=True)
+    hub = importlib.import_module("huggingface_hub")
+
+    index_cache = hub.hf_hub_download(
+        REPO,
+        f"{PREFIX}/TRAINING_EPISODES.jsonl",
+        repo_type="dataset",
+        revision=args.revision,
+    )
+    rows = [json.loads(line) for line in Path(index_cache).read_text().splitlines() if line]
+    if len(rows) != 2699:
+        raise RuntimeError(f"expected 2699 training episodes, got {len(rows)}")
+
+    patterns = sorted({row["canonical_zip_path"] for row in rows})
+    patterns.extend(
+        [
+            f"{PREFIX}/**",
+            f"{TARGET_PREFIX}/**",
+            "gwam_v12_sparse_v2_type_clip32_patch_20260725/**",
+            "loaders/gwam_full_graph_window.py",
+            "README.md",
+            "SCHEMA.md",
+        ]
+    )
+    if not args.no_realtime:
+        patterns.extend(
+            [
+                "realtime/**",
+                "examples/realtime_env_graph_eval_loop.py",
+                "docs/REALTIME_ENV_GRAPH_PIPELINE.md",
+                "scripts/setup_realtime_final_graph_env.sh",
+                "scripts/verify_realtime_final_graph.py",
+                "scripts/verify_rgb_graph_alignment.py",
+                "models/**",
+            ]
+        )
+
+    path = hub.snapshot_download(
+        REPO,
+        repo_type="dataset",
+        revision=args.revision,
+        allow_patterns=patterns,
+        local_dir=args.local_dir,
+    )
+    print(
+        json.dumps(
+            {
+                "status": "DOWNLOADED",
+                "root": str(Path(path).resolve()),
+                "revision": args.revision,
+                "episodes": len(rows),
+                "graph_rgb_included": False,
+                "next": (
+                    f"python {PREFIX}/loader/target_aware_gwam_training_dataset.py "
+                    f"--root {Path(path).resolve()} --index 0"
+                ),
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gwam_active13_gwam_training_v1_20260731/examples/VALIDATED_OUTPUT.json

@@ -0,0 +1,69 @@
+{
+  "artifact_type": "GWAMActive13DirectTrainingValidatedExamples",
+  "version": "1.0.0",
+  "offline_graph_only": {
+    "episode_key": "pretrain/PickPlaceCabinetToCounter/episode_000000",
+    "dataset_window_count": 702094,
+    "index": 0,
+    "history_gwam_node_features": [8, 79, 344],
+    "history_sam2_visual": [8, 79, 3, 256],
+    "history_view_evidence": [8, 79, 3, 8],
+    "future_action": [8, 12],
+    "target_count": 1,
+    "rgb_in_graph_zip": false
+  },
+  "prior_342_byte_equivalence": {
+    "episode_key": "pretrain/PickPlaceCabinetToCounter/episode_000000",
+    "frame": 0,
+    "new_first_342": [79, 342],
+    "prior_loader_x": [79, 342],
+    "exact_equal": true,
+    "max_absolute_difference": 0.0
+  },
+  "offline_separate_rgb_join": {
+    "episode_key": "pretrain/PickPlaceCabinetToCounter/episode_000000",
+    "rgb_frames": [16, 3, 256, 256, 3],
+    "dtype": "uint8",
+    "camera_order": [
+      "robot0_agentview_right",
+      "robot0_agentview_left",
+      "robot0_eye_in_hand"
+    ],
+    "source_frame_indices": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    "pixel_min": 0,
+    "pixel_max": 255,
+    "rgb_source": "separate RoboCasa/LeRobot source root"
+  },
+  "live_full_graph": {
+    "task": "OpenDrawer",
+    "N_real": 146,
+    "x": [146, 342],
+    "edge_index": [2, 106],
+    "edge_attr": [106, 8],
+    "sam2_feature_rows": 52,
+    "invalid_visible_pairs": 0,
+    "rgb_view_count": 3,
+    "rgb_shape_each": [256, 256, 3],
+    "rgb_aligned_with_view_ids": true
+  },
+  "live_target_aware_graph": {
+    "task": "PickPlaceCabinetToCounter",
+    "N_real": 125,
+    "x_target_aware": [125, 344],
+    "edge_index": [2, 91],
+    "edge_attr": [91, 8],
+    "target_node_ids": ["obj"],
+    "target_storage_slots": [1],
+    "target_provenance_status": "CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED",
+    "rgb_view_count": 3
+  },
+  "verification": {
+    "focused_tests": "9 passed",
+    "all_target_receipts": "2699 validated",
+    "two_worker_batch": {
+      "multiprocessing_context": "spawn",
+      "gwam_node_features": [2, 8, 79, 344],
+      "future_action": [2, 8, 12]
+    }
+  }
+}

gwam_active13_gwam_training_v1_20260731/examples/current_frame_target_aware_eval.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Generate one full target-aware GWAM graph from the current RoboCasa frame.
+
+The physical/visual graph is generated automatically from the current simulator
+state and three aligned RGB views. Target slots must be supplied from task/reset
+information known before action selection; this script refuses to infer them
+from actions, contacts, success, rewards, or future states.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+PREFIX_ROOT = Path(__file__).resolve().parents[1]
+REPO_ROOT = PREFIX_ROOT.parents[0]
+for path in (REPO_ROOT, PREFIX_ROOT / "loader"):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from realtime.gwam_realtime_env_graph import (  # noqa: E402
+    RealtimeGWAMGraphExtractor,
+    Sam2ClipRealtimeFeatureBackend,
+    save_realtime_graph_snapshot,
+)
+from target_aware_gwam_training_dataset import (  # noqa: E402
+    attach_known_task_targets_to_realtime_graph,
+)
+
+
+def make_env(task: str, robots: str):
+    import robocasa  # noqa: F401
+    import robosuite
+
+    return robosuite.make(
+        task,
+        robots=robots,
+        has_renderer=False,
+        has_offscreen_renderer=True,
+        use_object_obs=True,
+        use_camera_obs=True,
+        camera_names=[
+            "robot0_agentview_right",
+            "robot0_agentview_left",
+            "robot0_eye_in_hand",
+        ],
+        camera_heights=256,
+        camera_widths=256,
+        camera_depths=False,
+        reward_shaping=False,
+        ignore_done=True,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", default="OpenDrawer")
+    parser.add_argument("--robots", default="PandaOmron")
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument(
+        "--target-slot",
+        type=int,
+        action="append",
+        default=[],
+        help="Repeat for every complete task-target storage slot known from reset/task metadata",
+    )
+    parser.add_argument(
+        "--target-node-id",
+        action="append",
+        default=[],
+        help="Repeat for authored target node IDs, e.g. --target-node-id obj",
+    )
+    parser.add_argument(
+        "--target-provenance",
+        required=True,
+        help="Non-outcome source, e.g. 'RoboCasa reset task specification OpenDrawer'",
+    )
+    parser.add_argument("--save-dir", type=Path, required=True)
+    args = parser.parse_args()
+    if not args.target_slot and not args.target_node_id:
+        parser.error("provide at least one --target-slot or --target-node-id")
+
+    env = make_env(args.task, args.robots)
+    try:
+        env.reset()
+        backend = Sam2ClipRealtimeFeatureBackend(device=args.device)
+        extractor = RealtimeGWAMGraphExtractor(env)
+        snapshot = extractor.extract_final_graph(
+            visual_backend=backend,
+            include_masks=True,
+        )
+        nodes = snapshot["graph_static"]["nodes"]
+        node_to_slot = {node["node_id"]: slot for slot, node in enumerate(nodes)}
+        unknown_ids = sorted(set(args.target_node_id).difference(node_to_slot))
+        if unknown_ids:
+            raise RuntimeError(f"target node IDs are absent from current inventory: {unknown_ids}")
+        target_slots = sorted(
+            set(args.target_slot).union(node_to_slot[node_id] for node_id in args.target_node_id)
+        )
+        snapshot = attach_known_task_targets_to_realtime_graph(
+            snapshot,
+            target_storage_slots=target_slots,
+            provenance=args.target_provenance,
+        )
+        save_realtime_graph_snapshot(snapshot, args.save_dir)
+        graph = snapshot["gnn_graph"]
+        np.savez_compressed(
+            args.save_dir / "target_aware_graph.npz",
+            x_target_aware=graph["x_target_aware"],
+            is_task_target=graph["is_task_target"],
+            task_target_valid=graph["task_target_valid"],
+            slot_ids=graph["slot_ids"],
+            edge_index=graph["edge_index"],
+            edge_attr=graph["edge_attr"],
+        )
+        result = {
+            "status": "CURRENT_FRAME_TARGET_AWARE_GRAPH_GENERATED",
+            "task": args.task,
+            "N_real": int(graph["x"].shape[0]),
+            "physical_visual_feature_dim": int(graph["x"].shape[1]),
+            "target_aware_feature_dim": int(graph["x_target_aware"].shape[1]),
+            "edge_count": int(graph["edge_index"].shape[1]),
+            "edge_dim": int(graph["edge_attr"].shape[1]),
+            "target_storage_slots": target_slots,
+            "target_node_ids": args.target_node_id,
+            "rgb_view_count": len(snapshot["rgb_frames"]),
+            "rgb_cameras": list(snapshot["rgb_frame_cameras"]),
+            "saved_to": str(args.save_dir.resolve()),
+            "causal_time": "current state after reset and before the next action",
+        }
+        (args.save_dir / "target_aware_summary.json").write_text(
+            json.dumps(result, indent=2) + "\n", encoding="utf-8"
+        )
+        print(json.dumps(result, indent=2))
+    finally:
+        try:
+            env.close()
+        except Exception:
+            pass
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gwam_active13_gwam_training_v1_20260731/loader/target_aware_gwam_training_dataset.py

@@ -0,0 +1,635 @@
+#!/usr/bin/env python3
+"""Direct-use target-aware GWAM temporal training dataset.
+
+This loader joins three immutable public layers without rewriting them:
+  1. canonical GWAM v1.2 sparse-v2 episode ZIPs;
+  2. the strict full temporal graph-window loader;
+  3. GraphPacket-Slim v2.0.1 target-resolution receipts.
+
+It returns the original typed temporal graph plus a convenience 344-D rich GWAM
+node tensor: 342 prior-release dimensions + [is_task_target,
+task_target_valid]. Original RGB videos are not stored in graph ZIPs. When a
+local RoboCasa/LeRobot RGB root is supplied, the loader can decode exact
+history/future frames using graph/frames.jsonl::source_frame.
+"""
+from __future__ import annotations
+
+import argparse
+import bisect
+import hashlib
+import importlib.util
+import importlib
+import json
+import sys
+from collections import OrderedDict
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Literal, Sequence
+
+import numpy as np
+
+PREFIX = "gwam_active13_gwam_training_v1_20260731"
+TARGET_PREFIX = "gwam_active13_target_physical_v2_0_1_20260731"
+CAMERAS = (
+    "robot0_agentview_right",
+    "robot0_agentview_left",
+    "robot0_eye_in_hand",
+)
+FEATURE_SCHEMA = (
+    ("physical_state", 0, 20),
+    ("family_onehot", 20, 30),
+    ("sam2_view_valid_mean", 30, 286),
+    ("type_clip32", 286, 318),
+    ("view_evidence_right_left_wrist", 318, 342),
+    ("is_task_target", 342, 343),
+    ("task_target_valid", 343, 344),
+)
+
+
+class GWAMTrainingViewError(RuntimeError):
+    """Training view is missing, malformed, or provenance-inconsistent."""
+
+
+def _load_module(name: str, path: Path) -> ModuleType:
+    if not path.is_file():
+        raise GWAMTrainingViewError(f"required public loader is missing: {path}")
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise GWAMTrainingViewError(f"cannot import public loader: {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _decode_256_lsb_first(value: object) -> np.ndarray:
+    if not isinstance(value, str) or len(value) != 64:
+        raise GWAMTrainingViewError("target receipt bitset is not 256-bit lowercase hex")
+    try:
+        raw = bytes.fromhex(value)
+    except ValueError as error:
+        raise GWAMTrainingViewError("target receipt bitset is not hex") from error
+    return np.asarray(
+        [(raw[n // 8] >> (n % 8)) & 1 for n in range(256)], dtype=np.bool_
+    )
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _fuse_rich_history(
+    sample: dict[str, Any], is_target: np.ndarray, target_valid: np.ndarray
+) -> tuple[np.ndarray, np.ndarray]:
+    history = sample["history"]
+    state = np.asarray(history["state_plus_visibility"], dtype=np.float32)
+    if state.ndim != 3 or state.shape[2] != 20:
+        raise GWAMTrainingViewError("state_plus_visibility must be [L,N,20]")
+    length, nodes, _ = state.shape
+
+    family = np.asarray(history["family_id"], dtype=np.int64)
+    if family.shape != (nodes,) or np.any((family < 0) | (family > 9)):
+        raise GWAMTrainingViewError("family_id must be [N] in 0..9")
+    family_onehot = np.eye(10, dtype=np.float32)[family]
+    family_onehot = np.broadcast_to(family_onehot[None], (length, nodes, 10))
+
+    sam2 = np.asarray(history["sam2_visual"], dtype=np.float32)
+    sam2_valid = np.asarray(history["sam2_valid"], dtype=np.bool_)
+    if sam2.shape != (length, nodes, 3, 256) or sam2_valid.shape != (
+        length,
+        nodes,
+        3,
+    ):
+        raise GWAMTrainingViewError("SAM2 fields must be [L,N,3,256] and [L,N,3]")
+    masked = np.where(sam2_valid[..., None], sam2, 0.0)
+    counts = sam2_valid.sum(axis=2, dtype=np.int32)
+    visual_valid = counts > 0
+    visual = masked.sum(axis=2, dtype=np.float32) / np.maximum(counts[..., None], 1)
+    visual = np.where(visual_valid[..., None], visual, 0.0).astype(np.float32)
+
+    type_clip = np.asarray(history["type_clip32"], dtype=np.float32)
+    type_valid = np.asarray(history["type_clip_valid"], dtype=np.bool_)
+    if type_clip.shape != (nodes, 32) or type_valid.shape != (nodes,):
+        raise GWAMTrainingViewError("type_clip32 fields must be [N,32] and [N]")
+    type_clip = np.where(type_valid[:, None], type_clip, 0.0)
+    type_clip = np.broadcast_to(type_clip[None], (length, nodes, 32))
+
+    views = np.asarray(history["view_evidence"], dtype=np.float32)
+    if views.shape != (length, nodes, 3, 8):
+        raise GWAMTrainingViewError("view_evidence must be [L,N,3,8]")
+    views = views.reshape(length, nodes, 24)
+
+    if is_target.shape != (nodes,) or target_valid.shape != (nodes,):
+        raise GWAMTrainingViewError("target fields must align to active N")
+    target = np.stack((is_target, target_valid), axis=-1).astype(np.float32)
+    target = np.broadcast_to(target[None], (length, nodes, 2))
+
+    fused = np.concatenate(
+        (state, family_onehot, visual, type_clip, views, target), axis=-1
+    ).astype(np.float32)
+    if fused.shape != (length, nodes, 344):
+        raise GWAMTrainingViewError("fused rich history did not produce [L,N,344]")
+    return np.ascontiguousarray(fused), visual_valid
+
+
+def attach_known_task_targets_to_realtime_graph(
+    snapshot: dict[str, Any],
+    *,
+    target_storage_slots: Sequence[int],
+    provenance: str,
+) -> dict[str, Any]:
+    """Append the two target channels to a full online 342-D current graph.
+
+    `target_storage_slots` must come from task/reset information available before
+    action selection. This helper never guesses targets from contact, actions,
+    rewards, success, or a future state. The caller must provide the complete
+    target set; all active non-target nodes are then valid closed-world negatives.
+    """
+    if not isinstance(provenance, str) or not provenance.strip():
+        raise GWAMTrainingViewError("nonempty pre-action target provenance is required")
+    if any(token in provenance.lower() for token in ("future", "success", "reward", "outcome")):
+        raise GWAMTrainingViewError("target provenance names a forbidden outcome/future source")
+    graph = snapshot.get("gnn_graph")
+    if not isinstance(graph, dict):
+        raise GWAMTrainingViewError("realtime snapshot lacks gnn_graph")
+    x = np.asarray(graph.get("x"), dtype=np.float32)
+    slots = np.asarray(graph.get("slot_ids"), dtype=np.int64)
+    if x.ndim != 2 or x.shape[1] != 342 or slots.shape != (x.shape[0],):
+        raise GWAMTrainingViewError("realtime full graph must have x[N,342] and slot_ids[N]")
+    requested = list(target_storage_slots)
+    if not requested or any(type(slot) is not int or not 0 <= slot < 256 for slot in requested):
+        raise GWAMTrainingViewError("target_storage_slots must be a nonempty list of slots 0..255")
+    if requested != sorted(set(requested)):
+        raise GWAMTrainingViewError("target_storage_slots must be sorted and unique")
+    missing = sorted(set(requested).difference(int(slot) for slot in slots))
+    if missing:
+        raise GWAMTrainingViewError(f"target storage slots are absent from current graph: {missing}")
+    is_target = np.isin(slots, np.asarray(requested, dtype=np.int64))
+    target_valid = np.ones(slots.shape, dtype=np.bool_)
+    target_fields = np.stack((is_target, target_valid), axis=-1).astype(np.float32)
+    graph["is_task_target"] = is_target
+    graph["task_target_valid"] = target_valid
+    graph["x_target_aware"] = np.ascontiguousarray(np.concatenate((x, target_fields), axis=-1))
+    metadata = graph.setdefault("metadata", {})
+    metadata["target_provenance"] = provenance
+    metadata["target_provenance_status"] = "CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED"
+    metadata["target_storage_slots"] = requested
+    metadata["target_aware_feature_dim"] = 344
+    return snapshot
+
+
+def _numpy_to_torch(value: Any) -> Any:
+    if isinstance(value, np.ndarray):
+        if value.dtype.kind in {"U", "S", "O"}:
+            return value
+        torch = importlib.import_module("torch")
+        return torch.from_numpy(value)
+    if isinstance(value, dict):
+        return {key: _numpy_to_torch(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_numpy_to_torch(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_numpy_to_torch(item) for item in value)
+    return value
+
+
+class TargetAwareGWAMTrainingDataset:
+    """Map-style 702,094-window direct training view over immutable HF files."""
+
+    def __init__(
+        self,
+        root: str | Path,
+        *,
+        history_length: int = 8,
+        horizon: int = 8,
+        stride: int = 1,
+        as_torch: bool = False,
+        strict: bool = True,
+        verify_zip_on_first_open: bool = True,
+        validate_all_target_receipts: bool = False,
+        max_open_episodes: int = 2,
+        rgb_root: str | Path | None = None,
+        rgb_mode: Literal["none", "history", "history_future"] = "none",
+    ) -> None:
+        self.root = Path(root).expanduser().resolve()
+        self.prefix_root = self.root / PREFIX
+        if not self.prefix_root.is_dir():
+            raise GWAMTrainingViewError(f"training prefix is missing: {self.prefix_root}")
+        if history_length != 8 or horizon != 8:
+            raise GWAMTrainingViewError("v1 direct view is frozen to history=8, horizon=8")
+        if type(stride) is not int or stride <= 0:
+            raise GWAMTrainingViewError("stride must be a positive integer")
+        if type(max_open_episodes) is not int or max_open_episodes <= 0:
+            raise GWAMTrainingViewError("max_open_episodes must be positive")
+        if rgb_mode not in {"none", "history", "history_future"}:
+            raise GWAMTrainingViewError("rgb_mode is invalid")
+        if rgb_mode != "none" and rgb_root is None:
+            raise GWAMTrainingViewError(
+                "RGB is not in graph ZIPs; rgb_root is required for rgb_mode != none"
+            )
+        self.history_length = history_length
+        self.horizon = horizon
+        self.stride = stride
+        self.as_torch = bool(as_torch)
+        self.strict = bool(strict)
+        self.verify_zip_on_first_open = bool(verify_zip_on_first_open)
+        self.max_open_episodes = max_open_episodes
+        self.rgb_root = None if rgb_root is None else Path(rgb_root).expanduser().resolve()
+        self.rgb_mode = rgb_mode
+
+        base = _load_module(
+            "gwam_training_base_window",
+            self.root / "loaders/gwam_full_graph_window.py",
+        )
+        sidecar_module = _load_module(
+            "gwam_training_target_sidecar",
+            self.root / TARGET_PREFIX / "loader/graphpacket_slim_v2_sidecar.py",
+        )
+        self._episode_class = base.GWAMFullGraphEpisode
+        self._base_collate = base.collate_full_graph_windows
+        self._sidecar = sidecar_module.GraphPacketSlimV2SidecarDataset(
+            self.root / TARGET_PREFIX
+        )
+        if validate_all_target_receipts:
+            count = self._sidecar.validate_all()
+            if count != 2699:
+                raise GWAMTrainingViewError("target receipt census did not validate to 2699")
+
+        index_path = self.prefix_root / "TRAINING_EPISODES.jsonl"
+        index_payload = index_path.read_bytes()
+        try:
+            summary = json.loads((self.prefix_root / "DATASET_SUMMARY.json").read_text())
+        except (OSError, json.JSONDecodeError) as error:
+            raise GWAMTrainingViewError("training summary is missing or invalid") from error
+        if (
+            summary.get("index_sha256") != hashlib.sha256(index_payload).hexdigest()
+            or summary.get("episode_count") != 2699
+            or summary.get("window_count_L8_H8_stride1") != 702094
+            or summary.get("model_split") != "train"
+            or summary.get("rgb_in_graph_zip") is not False
+        ):
+            raise GWAMTrainingViewError("training index/summary authority binding differs")
+        rows: list[dict[str, Any]] = []
+        for line_number, line in enumerate(index_payload.decode("utf-8").splitlines(), 1):
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError as error:
+                raise GWAMTrainingViewError(
+                    f"training index line {line_number} is invalid JSON"
+                ) from error
+            if row.get("schema") != "gwam.active13.gwam_training_episode.v1":
+                raise GWAMTrainingViewError("training index schema differs")
+            if row.get("resolution_status") != "RESOLVED":
+                raise GWAMTrainingViewError("training view contains unresolved targets")
+            if row.get("model_split") != "train" or row.get("rgb_in_graph_zip") is not False:
+                raise GWAMTrainingViewError("training split/RGB status differs")
+            if row.get("history_length") != 8 or row.get("horizon") != 8:
+                raise GWAMTrainingViewError("training index temporal contract differs")
+            episode_key = row.get("episode_key")
+            sidecar_row = self._sidecar.index.get(episode_key)
+            expected_receipt_path = None
+            if sidecar_row is not None:
+                expected_receipt_path = f"{TARGET_PREFIX}/{sidecar_row['receipt_relative_path']}"
+            if (
+                sidecar_row is None
+                or sidecar_row.get("task") != row.get("task")
+                or sidecar_row.get("source_group_id") != row.get("source_group_id")
+                or sidecar_row.get("receipt_sha256") != row.get("target_receipt_sha256")
+                or sidecar_row.get("target_cardinality") != row.get("target_cardinality")
+                or expected_receipt_path != row.get("target_receipt_path")
+            ):
+                raise GWAMTrainingViewError("training index differs from target sidecar index")
+            rows.append(row)
+        if len(rows) != 2699 or len({row["episode_key"] for row in rows}) != 2699:
+            raise GWAMTrainingViewError("training index must contain 2699 unique episodes")
+        if len({row["canonical_zip_path"] for row in rows}) != 2699:
+            raise GWAMTrainingViewError("training index canonical ZIP paths are not unique")
+        self.rows = rows
+
+        self._window_counts = [
+            (int(row["valid_start_count"]) + stride - 1) // stride for row in rows
+        ]
+        self._cumulative: list[int] = []
+        total = 0
+        for count in self._window_counts:
+            if count <= 0:
+                raise GWAMTrainingViewError("training episode has no legal windows")
+            total += count
+            self._cumulative.append(total)
+        self._length = total
+        self._handles: OrderedDict[int, Any] = OrderedDict()
+        self._verified_zips: set[int] = set()
+        self._frame_maps: dict[int, dict[int, int]] = {}
+        self._video_paths: dict[tuple[int, str], Path] = {}
+
+    def __len__(self) -> int:
+        return self._length
+
+    def _locate(self, index: int) -> tuple[int, int]:
+        if index < 0:
+            index += self._length
+        if not 0 <= index < self._length:
+            raise IndexError(index)
+        episode_index = bisect.bisect_right(self._cumulative, index)
+        prior = 0 if episode_index == 0 else self._cumulative[episode_index - 1]
+        start_t = (index - prior) * self.stride
+        return episode_index, start_t
+
+    def _open(self, episode_index: int) -> Any:
+        if episode_index in self._handles:
+            handle = self._handles.pop(episode_index)
+            self._handles[episode_index] = handle
+            return handle
+        row = self.rows[episode_index]
+        zip_path = (self.root / row["canonical_zip_path"]).resolve()
+        if self.root not in zip_path.parents or zip_path.is_symlink() or not zip_path.is_file():
+            raise GWAMTrainingViewError(f"canonical ZIP is missing/unsafe: {zip_path}")
+        if self.verify_zip_on_first_open and episode_index not in self._verified_zips:
+            if zip_path.stat().st_size != row["canonical_zip_size"]:
+                raise GWAMTrainingViewError("canonical ZIP size differs from index")
+            if _sha256(zip_path) != row["canonical_zip_sha256"]:
+                raise GWAMTrainingViewError("canonical ZIP hash differs from index")
+            self._verified_zips.add(episode_index)
+        patch_root = self.root / "gwam_v12_sparse_v2_type_clip32_patch_20260725"
+        handle = self._episode_class(
+            zip_path=zip_path,
+            type_clip32_patch_root=patch_root,
+            strict=self.strict,
+        )
+        self._handles[episode_index] = handle
+        while len(self._handles) > self.max_open_episodes:
+            _, old = self._handles.popitem(last=False)
+            old.close()
+        return handle
+
+    def _source_frames(self, episode_index: int, handle: Any) -> dict[int, int]:
+        if episode_index in self._frame_maps:
+            return self._frame_maps[episode_index]
+        path = Path(handle.episode_dir) / "graph/frames.jsonl"
+        result: dict[int, int] = {}
+        for line in path.read_text(encoding="utf-8").splitlines():
+            if not line:
+                continue
+            row = json.loads(line)
+            t, source = row.get("t"), row.get("source_frame")
+            if type(t) is not int or type(source) is not int or t in result:
+                raise GWAMTrainingViewError("frames.jsonl source-frame mapping is invalid")
+            result[t] = source
+        self._frame_maps[episode_index] = result
+        return result
+
+    def _resolve_video(self, episode_index: int, camera: str) -> Path:
+        key = (episode_index, camera)
+        if key in self._video_paths:
+            return self._video_paths[key]
+        assert self.rgb_root is not None
+        row = self.rows[episode_index]
+        pattern = (
+            f"{row['source_tier']}/**/{row['task']}/**/lerobot/videos/chunk-*/"
+            f"observation.images.{camera}/{row['episode_id']}.mp4"
+        )
+        matches = sorted(self.rgb_root.glob(pattern))
+        if len(matches) != 1:
+            raise GWAMTrainingViewError(
+                f"expected one source RGB video for {row['episode_key']} {camera}, got {len(matches)}"
+            )
+        path = matches[0].resolve()
+        if self.rgb_root not in path.parents or path.is_symlink():
+            raise GWAMTrainingViewError("source RGB path is unsafe")
+        self._video_paths[key] = path
+        return path
+
+    def _decode_rgb(self, episode_index: int, source_frames: Sequence[int]) -> np.ndarray:
+        try:
+            cv2 = importlib.import_module("cv2")
+        except ImportError as error:
+            raise GWAMTrainingViewError("opencv-python is required to decode source RGB") from error
+        views: list[np.ndarray] = []
+        for camera in CAMERAS:
+            path = self._resolve_video(episode_index, camera)
+            capture = cv2.VideoCapture(str(path))
+            if not capture.isOpened():
+                raise GWAMTrainingViewError(f"cannot open source RGB video: {path}")
+            frames: list[np.ndarray] = []
+            try:
+                for frame_index in source_frames:
+                    capture.set(cv2.CAP_PROP_POS_FRAMES, int(frame_index))
+                    ok, bgr = capture.read()
+                    if not ok or bgr is None:
+                        raise GWAMTrainingViewError(
+                            f"cannot decode source frame {frame_index} from {path}"
+                        )
+                    rgb = np.ascontiguousarray(bgr[..., ::-1])
+                    if rgb.shape != (256, 256, 3) or rgb.dtype != np.uint8:
+                        raise GWAMTrainingViewError("source RGB must be uint8[256,256,3]")
+                    frames.append(rgb)
+            finally:
+                capture.release()
+            views.append(np.stack(frames, axis=0))
+        return np.ascontiguousarray(np.stack(views, axis=1))  # [T,3,256,256,3]
+
+    def __getitem__(self, index: int) -> dict[str, Any]:
+        episode_index, start_t = self._locate(index)
+        row = self.rows[episode_index]
+        handle = self._open(episode_index)
+        sample = handle.load_window(
+            start_t=start_t,
+            history_length=8,
+            horizon=8,
+            mask_size=16,
+            as_torch=False,
+        )
+        source_metadata = sample["metadata"]
+        expected_episode = f"episode_{int(source_metadata.get('episode', -1)):06d}"
+        if (
+            source_metadata.get("task") != row["task"]
+            or source_metadata.get("split") != row["source_tier"]
+            or expected_episode != row["episode_id"]
+            or int(source_metadata.get("T", -1)) != int(row["frames_processed"])
+        ):
+            raise GWAMTrainingViewError("canonical ZIP internal identity differs from training index")
+        receipt = self._sidecar.get_resolution_receipt(row["episode_key"])
+        if (
+            receipt.get("task") != row["task"]
+            or receipt.get("source_group_id") != row["source_group_id"]
+            or receipt.get("target_cardinality") != row["target_cardinality"]
+        ):
+            raise GWAMTrainingViewError("target receipt differs from training index")
+        slots = np.asarray(sample["metadata"]["slot_ids"], dtype=np.int64)
+        anchor_valid = np.asarray(sample["history"]["node_valid"][-1], dtype=np.bool_)
+        resolver_valid = _decode_256_lsb_first(receipt["resolver_valid_bitset_hex"])[slots]
+        target_bits = _decode_256_lsb_first(receipt["target_bitset_hex"])[slots]
+        target_valid = np.logical_and(resolver_valid, anchor_valid)
+        is_target = np.logical_and(target_bits, target_valid)
+        if np.any(np.logical_and(is_target, np.logical_not(target_valid))):
+            raise GWAMTrainingViewError("is_task_target exceeds task_target_valid")
+        fused, visual_valid = _fuse_rich_history(sample, is_target, target_valid)
+        sample["history"]["gwam_node_features"] = fused
+        sample["history"]["gwam_visual_feature_valid"] = visual_valid
+        sample["history"]["is_task_target"] = is_target
+        sample["history"]["task_target_valid"] = target_valid
+
+        frame_map = self._source_frames(episode_index, handle)
+        history_frames = [int(x) for x in sample["metadata"]["history_frames"]]
+        future_frames = [int(x) for x in sample["metadata"]["future_frames"]]
+        selected = history_frames if self.rgb_mode == "history" else history_frames + future_frames
+        source_selected = [frame_map[t] for t in selected]
+        rgb: dict[str, Any] = {
+            "included": self.rgb_mode != "none",
+            "stored_in_graph_zip": False,
+            "cameras": CAMERAS,
+            "mode": self.rgb_mode,
+            "graph_frame_indices": np.asarray(selected, dtype=np.int64),
+            "source_frame_indices": np.asarray(source_selected, dtype=np.int64),
+        }
+        if self.rgb_mode != "none":
+            rgb["frames"] = self._decode_rgb(episode_index, source_selected)
+        sample["rgb"] = rgb
+        sample["metadata"].update(
+            {
+                "training_view_schema": "gwam.active13.direct_training_sample.v1",
+                "training_index": int(index),
+                "training_episode_index": int(episode_index),
+                "episode_key": row["episode_key"],
+                "task": row["task"],
+                "source_tier": row["source_tier"],
+                "source_group_id": row["source_group_id"],
+                "target_receipt_sha256": row["target_receipt_sha256"],
+                "gwam_node_feature_dim": 344,
+                "gwam_feature_schema": FEATURE_SCHEMA,
+                "rgb_in_graph_zip": False,
+            }
+        )
+        return _numpy_to_torch(sample) if self.as_torch else sample
+
+    def collate(self, samples: list[dict[str, Any]], *, as_torch: bool | None = None) -> dict[str, Any]:
+        if not samples:
+            raise GWAMTrainingViewError("cannot collate an empty batch")
+        use_torch = self.as_torch if as_torch is None else bool(as_torch)
+        numpy_samples = samples
+        if any(not isinstance(s["history"]["gwam_node_features"], np.ndarray) for s in samples):
+            raise GWAMTrainingViewError("collate expects NumPy samples; construct dataset with as_torch=False")
+        batch = self._base_collate(numpy_samples, as_torch=False)
+        batch_size = len(samples)
+        length = samples[0]["history"]["gwam_node_features"].shape[0]
+        max_nodes = max(s["history"]["gwam_node_features"].shape[1] for s in samples)
+        fused = np.zeros((batch_size, length, max_nodes, 344), dtype=np.float32)
+        visual_valid = np.zeros((batch_size, length, max_nodes), dtype=np.bool_)
+        target = np.zeros((batch_size, max_nodes), dtype=np.bool_)
+        target_valid = np.zeros((batch_size, max_nodes), dtype=np.bool_)
+        for b, sample in enumerate(samples):
+            n = sample["history"]["gwam_node_features"].shape[1]
+            fused[b, :, :n] = sample["history"]["gwam_node_features"]
+            visual_valid[b, :, :n] = sample["history"]["gwam_visual_feature_valid"]
+            target[b, :n] = sample["history"]["is_task_target"]
+            target_valid[b, :n] = sample["history"]["task_target_valid"]
+        batch["history"]["gwam_node_features"] = fused
+        batch["history"]["gwam_visual_feature_valid"] = visual_valid
+        batch["history"]["is_task_target"] = target
+        batch["history"]["task_target_valid"] = target_valid
+        if all(bool(s["rgb"]["included"]) for s in samples):
+            batch["rgb"] = {
+                "included": True,
+                "stored_in_graph_zip": False,
+                "cameras": CAMERAS,
+                "mode": samples[0]["rgb"]["mode"],
+                "frames": np.stack([s["rgb"]["frames"] for s in samples], axis=0),
+                "graph_frame_indices": np.stack(
+                    [s["rgb"]["graph_frame_indices"] for s in samples], axis=0
+                ),
+                "source_frame_indices": np.stack(
+                    [s["rgb"]["source_frame_indices"] for s in samples], axis=0
+                ),
+            }
+        else:
+            batch["rgb"] = {
+                "included": False,
+                "stored_in_graph_zip": False,
+                "cameras": CAMERAS,
+                "mode": "none",
+            }
+        batch["gwam_feature_schema"] = FEATURE_SCHEMA
+        return _numpy_to_torch(batch) if use_torch else batch
+
+    def collate_torch(self, samples: list[dict[str, Any]]) -> dict[str, Any]:
+        """Picklable DataLoader collator that always returns torch tensors."""
+        return self.collate(samples, as_torch=True)
+
+    def close(self) -> None:
+        while self._handles:
+            _, handle = self._handles.popitem(last=False)
+            handle.close()
+        self._frame_maps.clear()
+
+    def __enter__(self) -> "TargetAwareGWAMTrainingDataset":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = dict(self.__dict__)
+        # Do not close the parent's live handles while preparing worker state.
+        # Workers reopen their own bounded cache through __setstate__.
+        state["_handles"] = OrderedDict()
+        state["_frame_maps"] = {}
+        state["_video_paths"] = {}
+        state.pop("_episode_class", None)
+        state.pop("_base_collate", None)
+        state.pop("_sidecar", None)
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        base = _load_module(
+            "gwam_training_base_window",
+            self.root / "loaders/gwam_full_graph_window.py",
+        )
+        sidecar_module = _load_module(
+            "gwam_training_target_sidecar",
+            self.root / TARGET_PREFIX / "loader/graphpacket_slim_v2_sidecar.py",
+        )
+        self._episode_class = base.GWAMFullGraphEpisode
+        self._base_collate = base.collate_full_graph_windows
+        self._sidecar = sidecar_module.GraphPacketSlimV2SidecarDataset(
+            self.root / TARGET_PREFIX
+        )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, required=True, help="Downloaded GWAM_Data root")
+    parser.add_argument("--index", type=int, default=0)
+    parser.add_argument("--skip-zip-hash", action="store_true")
+    args = parser.parse_args()
+    with TargetAwareGWAMTrainingDataset(
+        args.root,
+        verify_zip_on_first_open=not args.skip_zip_hash,
+        validate_all_target_receipts=False,
+    ) as dataset:
+        sample = dataset[args.index]
+        summary = {
+            "dataset_windows": len(dataset),
+            "episode_key": sample["metadata"]["episode_key"],
+            "history_gwam_node_features": list(
+                sample["history"]["gwam_node_features"].shape
+            ),
+            "history_view_evidence": list(sample["history"]["view_evidence"].shape),
+            "history_sam2_visual": list(sample["history"]["sam2_visual"].shape),
+            "future_action": list(sample["future_action"].shape),
+            "target_count": int(sample["history"]["is_task_target"].sum()),
+            "rgb_included": bool(sample["rgb"]["included"]),
+            "rgb_stored_in_graph_zip": False,
+        }
+        print(json.dumps(summary, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gwam_active13_gwam_training_v1_20260731/manifests/PUBLICATION_MANIFEST.json

@@ -0,0 +1,72 @@
+{
+  "artifact_type": "GWAMActive13DirectTrainingPublicationManifest",
+  "base_revision": "dd57b9c35ca819a17d666ec07099215dd16facf3",
+  "file_count": 13,
+  "files": [
+    {
+      "path": "README.md",
+      "sha256": "1ae8e2dff547912e5d27e944b5be1047ce2b10dfe5fbb820eeae795721c6a4c8",
+      "size": 28332
+    },
+    {
+      "path": "SCHEMA.md",
+      "sha256": "06f6dd17112e29db01b44b14f43828465c860340819380330cef91fcd1befec3",
+      "size": 19219
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/DATASET_SUMMARY.json",
+      "sha256": "9e18f43cbd83cf32e7354e3a992d83dd829f2d8cc0bf57a2353ec84e11bc26a4",
+      "size": 1584
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/README.md",
+      "sha256": "1dc8ddca6d6c5af9552e82bc17e014bef3f78cf97b60425f85ab51ecd39a3ba2",
+      "size": 11822
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/RGB_AND_REALTIME.md",
+      "sha256": "8717362efe0979ce4dd44581f96ee0a2c2cfb44e9b025c3201b2507016eb4df7",
+      "size": 6132
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/SCHEMA.md",
+      "sha256": "1d99fad9c4755fc100cf225c9d4ec92338d986f4b59368fa229e0d859e22d4a8",
+      "size": 5990
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/TRAINING_EPISODES.jsonl",
+      "sha256": "757b3320ba991a2ece0c0a2a431cfde84db24e6837871855072b28663d89859e",
+      "size": 3168112
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/download_training_data.py",
+      "sha256": "bfc04a9fc00d4500f662e77b71629ec60b4bcb62456e817f7d554fab18ec8e08",
+      "size": 3059
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/examples/VALIDATED_OUTPUT.json",
+      "sha256": "023da5260b7ed665c00b8075348aa67f3a3e2cfda98b9bf74ec2fc062b6ff4e6",
+      "size": 2110
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/examples/current_frame_target_aware_eval.py",
+      "sha256": "a5d4a758d574694668cf439c204f6421ab6ba361057090672b45c2317fc2c8a2",
+      "size": 5236
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/loader/target_aware_gwam_training_dataset.py",
+      "sha256": "4ec45b4fc38b71a2194289ec4d572e521815b2bc19ffc761574b64b9e076fcda",
+      "size": 29665
+    },
+    {
+      "path": "gwam_active13_gwam_training_v1_20260731/tests/test_direct_training_view.py",
+      "sha256": "8d6427e4da3f9c21c95643b6aecae2fcd970eddbffb94c9f6b8a154c92f67d16",
+      "size": 9071
+    },
+    {
+      "path": "scripts/setup_realtime_final_graph_env.sh",
+      "sha256": "cc0043d93bd2500218b2a962865c890468c110bef7f66e763fb8aa475c683509",
+      "size": 5171
+    }
+  ]
+}

gwam_active13_gwam_training_v1_20260731/receipts/PREPUBLICATION_VALIDATION_RECEIPT.json

@@ -0,0 +1,137 @@
+{
+  "artifact_type": "GWAMActive13DirectTrainingPrepublicationReceipt",
+  "base_revision": "dd57b9c35ca819a17d666ec07099215dd16facf3",
+  "boundaries": [
+    "canonical graph ZIPs do not contain original RGB/video bytes",
+    "separate source RoboCasa/LeRobot RGB required for pixel/video training",
+    "target sidecar is outer-train only",
+    "future graph/RGB never used to select input topology or targets",
+    "live target fields are caller-asserted and require external reset/task receipt binding"
+  ],
+  "created_at": "2026-07-31T12:13:57-05:00",
+  "dataset": {
+    "episode_count": 2699,
+    "rgb_in_graph_zip": false,
+    "window_count": 702094
+  },
+  "index": {
+    "canonical_zip_bytes": 20339307035,
+    "episodes": 2699,
+    "model_split": "train",
+    "sha256": "757b3320ba991a2ece0c0a2a431cfde84db24e6837871855072b28663d89859e",
+    "windows_L8_H8_stride1": 702094
+  },
+  "planned_tag": "gwam-target-v2.0.1-training-v1",
+  "publication_manifest_sha256": "9ad4db2dae2ba8a04d01577574a7aacab7d0fa468a92670dcb296111600cf62d",
+  "setup_validation": {
+    "cuda": "13.0",
+    "cuda_smoke": 8.0,
+    "fresh_live_asset_boundary": "RoboCasa kitchen assets are separate and not redistributed",
+    "robocasa_commit": "b4684e6ee37d377cc392e98302a6b916d588b415",
+    "robosuite_commit": "5ce6643f3092639d08f7b0f90ed1c6a84f50552c",
+    "sam2_commit": "2b90b9f5ceec907a1c18123530e92e794ad901a4",
+    "script_exit_code": 0,
+    "torch": "2.13.0+cu130"
+  },
+  "status": "READY_TO_PUBLISH",
+  "training_index_sha256": "757b3320ba991a2ece0c0a2a431cfde84db24e6837871855072b28663d89859e",
+  "validated_examples": {
+    "live_sam2_full_graph": {
+      "edge_index": [
+        2,
+        106
+      ],
+      "invalid_visible_pairs": 0,
+      "sam2_feature_rows": 52,
+      "task": "OpenDrawer",
+      "x": [
+        146,
+        342
+      ]
+    },
+    "live_target_aware": {
+      "target_node_ids": [
+        "obj"
+      ],
+      "target_provenance_status": "CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED",
+      "target_storage_slots": [
+        1
+      ],
+      "task": "PickPlaceCabinetToCounter",
+      "x_target_aware": [
+        125,
+        344
+      ]
+    },
+    "multiprocessing_spawn_batch": {
+      "future_action": [
+        2,
+        8,
+        12
+      ],
+      "gwam_node_features": [
+        2,
+        8,
+        79,
+        344
+      ]
+    },
+    "offline_graph_only": {
+      "episode_key": "pretrain/PickPlaceCabinetToCounter/episode_000000",
+      "future_action": [
+        8,
+        12
+      ],
+      "gwam_node_features": [
+        8,
+        79,
+        344
+      ],
+      "target_count": 1
+    },
+    "offline_rgb_join": {
+      "dtype": "uint8",
+      "rgb_frames": [
+        16,
+        3,
+        256,
+        256,
+        3
+      ],
+      "source_frames": [
+        0,
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15
+      ]
+    },
+    "prior_342_byte_equivalence": {
+      "exact_equal": true,
+      "max_absolute_difference": 0.0,
+      "shape": [
+        79,
+        342
+      ]
+    }
+  },
+  "validation": {
+    "canonical_sample_zip_sha256_verified": true,
+    "focused_tests": "9 passed",
+    "legacy_realtime_and_graph_loader_tests": "16 passed",
+    "real_sam2_current_frame": true,
+    "real_source_rgb_decode": true,
+    "target_receipts_validated": 2699
+  }
+}

gwam_active13_gwam_training_v1_20260731/tests/test_direct_training_view.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import pickle
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+PREFIX = Path(__file__).resolve().parents[1]
+UPLOAD = PREFIX.parent
+INDEX = PREFIX / "TRAINING_EPISODES.jsonl"
+SUMMARY = PREFIX / "DATASET_SUMMARY.json"
+LOADER = PREFIX / "loader/target_aware_gwam_training_dataset.py"
+
+
+def _module():
+    spec = importlib.util.spec_from_file_location("target_aware_training_tested", LOADER)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_training_index_and_summary_are_exact() -> None:
+    payload = INDEX.read_bytes()
+    rows = [json.loads(line) for line in payload.decode().splitlines() if line]
+    summary = json.loads(SUMMARY.read_text())
+    assert len(rows) == 2699
+    assert len({row["episode_key"] for row in rows}) == 2699
+    assert sum(row["valid_start_count"] for row in rows) == 702094
+    assert all(row["resolution_status"] == "RESOLVED" for row in rows)
+    assert all(row["model_split"] == "train" for row in rows)
+    assert all(row["rgb_in_graph_zip"] is False for row in rows)
+    assert all(row["valid_start_count"] == row["frames_processed"] - 15 for row in rows)
+    assert summary["episode_count"] == 2699
+    assert summary["window_count_L8_H8_stride1"] == 702094
+    assert summary["canonical_zip_bytes_referenced"] == 20339307035
+    assert summary["index_sha256"] == hashlib.sha256(payload).hexdigest()
+
+
+def test_live_target_attachment_produces_344_and_fails_closed() -> None:
+    module = _module()
+    snapshot = {
+        "gnn_graph": {
+            "x": np.zeros((3, 342), dtype=np.float32),
+            "slot_ids": np.array([0, 2, 7], dtype=np.int64),
+            "metadata": {},
+        }
+    }
+    out = module.attach_known_task_targets_to_realtime_graph(
+        snapshot,
+        target_storage_slots=[2, 7],
+        provenance="RoboCasa reset task specification",
+    )
+    graph = out["gnn_graph"]
+    assert graph["x_target_aware"].shape == (3, 344)
+    assert graph["is_task_target"].tolist() == [False, True, True]
+    assert graph["task_target_valid"].tolist() == [True, True, True]
+    assert np.array_equal(graph["x_target_aware"][:, 342] > 0, graph["is_task_target"])
+    assert graph["metadata"]["target_provenance_status"] == "CALLER_ASSERTED_PRE_ACTION_NOT_AUTHENTICATED"
+    with pytest.raises(module.GWAMTrainingViewError):
+        module.attach_known_task_targets_to_realtime_graph(
+            {"gnn_graph": {"x": np.zeros((1, 342)), "slot_ids": np.array([0])}},
+            target_storage_slots=[0],
+            provenance="future success outcome",
+        )
+    with pytest.raises(module.GWAMTrainingViewError):
+        module.attach_known_task_targets_to_realtime_graph(
+            {"gnn_graph": {"x": np.zeros((1, 342)), "slot_ids": np.array([0])}},
+            target_storage_slots=[4],
+            provenance="reset task specification",
+        )
+
+
+def test_rgb_requires_separate_source_root() -> None:
+    module = _module()
+    root = Path(os.environ.get("GWAM_DATA_ROOT", "/nonexistent-gwam-root"))
+    if not (root / module.PREFIX).is_dir():
+        pytest.skip("full local GWAM root not supplied")
+    with pytest.raises(module.GWAMTrainingViewError, match="RGB is not in graph ZIPs"):
+        module.TargetAwareGWAMTrainingDataset(root, rgb_mode="history")
+
+
+def test_real_training_window_and_torch_collation() -> None:
+    module = _module()
+    root = Path(os.environ.get("GWAM_DATA_ROOT", "/nonexistent-gwam-root"))
+    if not (root / module.PREFIX).is_dir():
+        pytest.skip("full local GWAM root not supplied")
+    with module.TargetAwareGWAMTrainingDataset(
+        root,
+        validate_all_target_receipts=True,
+        max_open_episodes=1,
+    ) as dataset:
+        assert len(dataset) == 702094
+        first = dataset[0]
+        second = dataset[1]
+        assert first["history"]["gwam_node_features"].shape == (8, 79, 344)
+        assert first["history"]["view_evidence"].shape == (8, 79, 3, 8)
+        assert first["history"]["sam2_visual"].shape == (8, 79, 3, 256)
+        assert first["future_action"].shape == (8, 12)
+        assert int(first["history"]["is_task_target"].sum()) == 1
+        assert first["rgb"]["included"] is False
+        batch = dataset.collate([first, second], as_torch=True)
+        assert tuple(batch["history"]["gwam_node_features"].shape) == (2, 8, 79, 344)
+        assert tuple(batch["future_action"].shape) == (2, 8, 12)
+        assert str(type(batch["history"]["gwam_node_features"])) == "<class 'torch.Tensor'>"
+        restored = pickle.loads(pickle.dumps(dataset))
+        try:
+            assert restored[0]["history"]["gwam_node_features"].shape == (8, 79, 344)
+        finally:
+            restored.close()
+        assert dataset[1]["history"]["gwam_node_features"].shape == (8, 79, 344)
+
+
+def test_real_source_rgb_join_when_available() -> None:
+    module = _module()
+    root = Path(os.environ.get("GWAM_DATA_ROOT", "/nonexistent-gwam-root"))
+    rgb_root = Path(os.environ.get("GWAM_RGB_ROOT", "/nonexistent-gwam-rgb-root"))
+    if not (root / module.PREFIX).is_dir() or not rgb_root.is_dir():
+        pytest.skip("full graph root and source RGB root not supplied")
+    with module.TargetAwareGWAMTrainingDataset(
+        root,
+        rgb_root=rgb_root,
+        rgb_mode="history_future",
+        max_open_episodes=1,
+    ) as dataset:
+        sample = dataset[0]
+        assert sample["rgb"]["frames"].shape == (16, 3, 256, 256, 3)
+        assert sample["rgb"]["frames"].dtype == np.uint8
+        assert sample["rgb"]["source_frame_indices"].tolist() == list(range(16))
+        assert sample["rgb"]["stored_in_graph_zip"] is False
+
+
+def test_docs_make_rgb_and_online_boundaries_explicit() -> None:
+    readme = (PREFIX / "README.md").read_text()
+    schema = (PREFIX / "SCHEMA.md").read_text()
+    rgb = (PREFIX / "RGB_AND_REALTIME.md").read_text()
+    root_readme = (UPLOAD / "README.md").read_text()
+    for phrase in (
+        "702,094 legal",
+        "do not contain original RGB videos",
+        "extract_final_graph()",
+        "344 total dimensions",
+        "current_frame_target_aware_eval.py",
+    ):
+        assert phrase in readme
+    assert "Canonical graph ZIPs do not contain RGB/video bytes" in schema
+    assert "extract_current_graph()` is Phase-1/debug only" in schema
+    assert "The graph ZIPs do **not** contain original video or RGB images" in rgb
+    assert "gwam_active13_gwam_training_v1_20260731" in root_readme
+    assert "gwam-target-v2.0.1-training-v1" in root_readme
+    validated = json.loads((PREFIX / "examples/VALIDATED_OUTPUT.json").read_text())
+    assert validated["offline_graph_only"]["history_gwam_node_features"] == [8, 79, 344]
+    assert validated["prior_342_byte_equivalence"]["exact_equal"] is True
+    assert validated["prior_342_byte_equivalence"]["max_absolute_difference"] == 0.0
+    assert validated["offline_separate_rgb_join"]["rgb_frames"] == [16, 3, 256, 256, 3]
+    assert validated["live_target_aware_graph"]["x_target_aware"] == [125, 344]
+
+
+def test_python_sources_compile() -> None:
+    for path in [
+        LOADER,
+        PREFIX / "download_training_data.py",
+        PREFIX / "examples/current_frame_target_aware_eval.py",
+    ]:
+        compile(path.read_text(encoding="utf-8"), str(path), "exec")
+
+def test_realtime_setup_uses_compatible_pinned_sources() -> None:
+    setup = (UPLOAD / "scripts/setup_realtime_final_graph_env.sh").read_text()
+    assert "python -m pip install numpy opencv-python robosuite==1.5.2" not in setup
+    assert "ARISE-Initiative/robosuite.git" in setup
+    for digest in (
+        "5ce6643f3092639d08f7b0f90ed1c6a84f50552c",
+        "b4684e6ee37d377cc392e98302a6b916d588b415",
+        "2b90b9f5ceec907a1c18123530e92e794ad901a4",
+        "d05afc436d78f1c48dc0dbf8e5980a9d471f35f6",
+    ):
+        assert digest in setup
+
+
+def test_publication_manifest_and_receipt_bind_all_nonself_files() -> None:
+    manifest_path = PREFIX / "manifests/PUBLICATION_MANIFEST.json"
+    receipt_path = PREFIX / "receipts/PREPUBLICATION_VALIDATION_RECEIPT.json"
+    manifest = json.loads(manifest_path.read_text())
+    receipt = json.loads(receipt_path.read_text())
+    assert manifest["base_revision"] == "dd57b9c35ca819a17d666ec07099215dd16facf3"
+    assert manifest["file_count"] == len(manifest["files"])
+    assert manifest["file_count"] >= 12
+    for row in manifest["files"]:
+        path = UPLOAD / row["path"]
+        payload = path.read_bytes()
+        assert len(payload) == row["size"]
+        assert hashlib.sha256(payload).hexdigest() == row["sha256"]
+    assert receipt["status"] == "READY_TO_PUBLISH"
+    assert receipt["publication_manifest_sha256"] == hashlib.sha256(
+        manifest_path.read_bytes()
+    ).hexdigest()
+    assert receipt["training_index_sha256"] == hashlib.sha256(INDEX.read_bytes()).hexdigest()
+    assert receipt["dataset"]["rgb_in_graph_zip"] is False

scripts/setup_realtime_final_graph_env.sh

@@ -18,46 +18,73 @@ set -euo pipefail
 ENV_NAME="${1:-robocasa}"
 WORK_ROOT="${GWAM_SETUP_ROOT:-$HOME/gwam_realtime_deps}"
 ROBOCASA_ROOT="${ROBOCASA_ROOT:-$WORK_ROOT/robocasa}"
+ROBOSUITE_ROOT="${ROBOSUITE_ROOT:-$WORK_ROOT/robosuite}"
 SAM2_ROOT="${SAM2_ROOT:-$WORK_ROOT/sam2}"
+ROBOSUITE_COMMIT="5ce6643f3092639d08f7b0f90ed1c6a84f50552c"
+ROBOCASA_COMMIT="b4684e6ee37d377cc392e98302a6b916d588b415"
+SAM2_COMMIT="2b90b9f5ceec907a1c18123530e92e794ad901a4"
+CLIP_COMMIT="d05afc436d78f1c48dc0dbf8e5980a9d471f35f6"
 
-if ! command -v conda >/dev/null 2>&1; then
-  if [[ -f /home/chris/anaconda3/etc/profile.d/conda.sh ]]; then
-    # shellcheck source=/dev/null
-    source /home/chris/anaconda3/etc/profile.d/conda.sh
-  else
-    echo "conda not found; install Miniconda/Anaconda first" >&2
-    exit 2
-  fi
+if command -v conda >/dev/null 2>&1; then
+  CONDA_EXE="$(command -v conda)"
+elif [[ -x /home/chris/anaconda3/bin/conda ]]; then
+  CONDA_EXE="/home/chris/anaconda3/bin/conda"
 else
-  # shellcheck source=/dev/null
-  source "$(conda info --base)/etc/profile.d/conda.sh"
+  echo "conda not found; install Miniconda/Anaconda first" >&2
+  exit 2
 fi
 
-if ! conda env list | awk '{print $1}' | grep -qx "$ENV_NAME"; then
-  conda create -y -n "$ENV_NAME" python=3.11
+if ! "$CONDA_EXE" env list | awk '{print $1}' | grep -qx "$ENV_NAME"; then
+  "$CONDA_EXE" create -y -n "$ENV_NAME" python=3.11
 fi
-conda activate "$ENV_NAME"
+CONDA_BASE="$("$CONDA_EXE" info --base)"
+ENV_PREFIX="$("$CONDA_BASE/bin/python" - "$ENV_NAME" <<'PY'
+import json, subprocess, sys
+name = sys.argv[1]
+payload = json.loads(subprocess.check_output([sys.executable.replace('/bin/python', '/bin/conda'), 'env', 'list', '--json'], text=True))
+matches = [path for path in payload['envs'] if path.rsplit('/', 1)[-1] == name]
+if len(matches) != 1:
+    raise SystemExit(f'expected one conda environment named {name}, got {matches}')
+print(matches[0])
+PY
+)"
+PYTHON="$ENV_PREFIX/bin/python"
 
-python -m pip install --upgrade pip
-python -m pip install numpy opencv-python robosuite==1.5.2
-python -m pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130
-python -m pip install git+https://github.com/openai/CLIP.git
+"$PYTHON" -m pip install --upgrade pip
+"$PYTHON" -m pip install numpy opencv-python
+"$PYTHON" -m pip install "git+https://github.com/openai/CLIP.git@${CLIP_COMMIT}"
 
 mkdir -p "$WORK_ROOT"
-if ! python - <<'PY' >/dev/null 2>&1
-import robocasa
-PY
-then
-  if [[ ! -d "$ROBOCASA_ROOT/.git" ]]; then
-    git clone https://github.com/robocasa/robocasa.git "$ROBOCASA_ROOT"
-  fi
-  python -m pip install -e "$ROBOCASA_ROOT"
+
+# RoboCasa main requires robosuite master APIs such as load_model_on_init.
+# The PyPI robosuite==1.5.2 release is not compatible with RoboCasa 1.0.1.
+if [[ ! -d "$ROBOSUITE_ROOT/.git" ]]; then
+  git clone https://github.com/ARISE-Initiative/robosuite.git "$ROBOSUITE_ROOT"
+fi
+git -C "$ROBOSUITE_ROOT" fetch origin "$ROBOSUITE_COMMIT"
+git -C "$ROBOSUITE_ROOT" checkout --detach "$ROBOSUITE_COMMIT"
+"$PYTHON" -m pip install -e "$ROBOSUITE_ROOT"
+
+if [[ ! -d "$ROBOCASA_ROOT/.git" ]]; then
+  git clone https://github.com/robocasa/robocasa.git "$ROBOCASA_ROOT"
 fi
+git -C "$ROBOCASA_ROOT" fetch origin "$ROBOCASA_COMMIT"
+git -C "$ROBOCASA_ROOT" checkout --detach "$ROBOCASA_COMMIT"
+"$PYTHON" -m pip install -e "$ROBOCASA_ROOT"
 
 if [[ ! -d "$SAM2_ROOT/.git" ]]; then
   git clone https://github.com/facebookresearch/sam2.git "$SAM2_ROOT"
 fi
-python -m pip install -e "$SAM2_ROOT"
+git -C "$SAM2_ROOT" fetch origin "$SAM2_COMMIT"
+git -C "$SAM2_ROOT" checkout --detach "$SAM2_COMMIT"
+"$PYTHON" -m pip install -e "$SAM2_ROOT"
+
+# RoboCasa/LeRobot dependencies may downgrade torch to a CUDA 12.6 wheel that
+# cannot execute on Blackwell (sm_120). Re-assert the CUDA 13 wheel last.
+"$PYTHON" -m pip install --upgrade torch torchvision --index-url https://download.pytorch.org/whl/cu130
+# Reinstall NCCL from PyPI: the dependency copy selected during mixed-index
+# resolution can carry the same version metadata but omit ncclCommResume.
+"$PYTHON" -m pip install --force-reinstall --no-cache-dir nvidia-nccl-cu13==2.29.7
 
 cat <<'EOF'
 
@@ -66,7 +93,7 @@ RoboCasa kitchen assets according to upstream RoboCasa instructions before runni
 live simulator tasks. This dataset does not redistribute RoboCasa assets.
 EOF
 
-python - <<'PY'
+"$PYTHON" - <<'PY'
 import importlib.util
 missing=[]
 for m in ['robocasa','robosuite','torch','clip','sam2','cv2','numpy']:
@@ -77,3 +104,29 @@ if missing:
     raise SystemExit(f'missing imports: {missing}')
 print('setup_realtime_final_graph_env_ok')
 PY
+
+"$PYTHON" - <<'PY'
+import torch
+print("torch", torch.__version__, "cuda", torch.version.cuda, "available", torch.cuda.is_available())
+if torch.cuda.is_available():
+    value = float((torch.ones(8, device="cuda") ** 2).sum().item())
+    if value != 8.0:
+        raise SystemExit(f"CUDA execution smoke differs: {value}")
+    print("setup_realtime_final_graph_cuda_smoke_ok", value)
+PY
+
+"$PYTHON" - <<PY
+from pathlib import Path
+checks = {
+    Path("$ROBOSUITE_ROOT"): "$ROBOSUITE_COMMIT",
+    Path("$ROBOCASA_ROOT"): "$ROBOCASA_COMMIT",
+    Path("$SAM2_ROOT"): "$SAM2_COMMIT",
+}
+import subprocess
+for root, expected in checks.items():
+    got = subprocess.check_output(["git", "-C", str(root), "rev-parse", "HEAD"], text=True).strip()
+    print(root.name, got)
+    if got != expected:
+        raise SystemExit(f"commit mismatch for {root}: {got} != {expected}")
+print("setup_realtime_final_graph_commits_ok")
+PY