GWAM_Data — Cosmos Policy RoboCasa v0.1 Dataset v1.0.0

Current final graph pattern: V3.0.7-compat
Current final Qwen pattern: Qwen v1.0.1
Released source components: graph core + articulation/edges v2 + corrected full Qwen v1.0.1 + aligned right/left/wrist RGB
Materialization boundary: V3.0.7 conversion/production-loader package remains pending
Training/evaluation: not started

1. Dataset overview

This is the current Cosmos Policy RoboCasa v0.1 same-benchmark corpus: all 24 Cosmos Policy tasks, all 1,320 original human demonstrations (55 per task), and 351,213 replay-aligned graph frames. The corpus release name is Cosmos-v0.1 Dataset v1.0.0.

The three version axes are separate and must not be combined:

Axis	Current final name	Meaning	Artifact status
Corpus	Cosmos-v0.1 Dataset v1.0.0	task, episode, replay, and evaluation authority	graph core + articulation/edges v2 + RGB companion RELEASED
Graph pattern	V3.0.7-compat	compact typed-graph contract intended for the planned joint-training path	articulation prerequisite CLEARED; conversion PENDING
Semantic pattern	Qwen v1.0.1	camera/node visual-semantic sidecar contract	corrected full 1,320-demo data RELEASED

Dataset v1.0.0 is not the graph version. V3.0.7-compat is not the Qwen version. A frozen pattern describes the intended representation/interface; it does not imply that every 24-task artifact has already passed release gates.

Final source version — use this combination

For the intended RGB-conditioned joint multiview training path, use all four released source components below.

Need	Final authority to use	Do not use
node identity, pose, targets, three views, actions, contacts, fixture state	graph core v1.0.0	historical local graph trees or unverified HDF5-derived arrays
articulation and repaired structural topology	articulation/edges v2 v1.0.0: articulation_q_v2, validity, binding table, structural_edges_v2	graph core structural_edges as the final repaired topology; old articulation v1
camera/node semantic evidence	corrected Qwen v1.0.1 full data v1.0.0	453 superseded diagnostic sidecars; 48 pilot sidecars
raw visual input for the joint multiview backbone	aligned RGB companion v1.0.0: right/left/wrist JPEG frames indexed by task/demo/frame/camera/packet	treating Qwen embeddings or graph view geometry as reconstructable RGB pixels
dynamic physical interaction	graph-core contact_offsets/contact_pairs	treating structural edges or generic robot contact as semantic holding

The final offline composition is:

graph core
+ pose-phase articulation_q_v2 / articulation_valid_v2
+ structural_edges_v2 (replaces historical structural_edges for repaired topology)
+ dynamic contact_pairs (kept separate)
+ corrected Qwen embedding_mrl256 attached by packet/frame/camera/slot/bbox
+ aligned RGB[t,camera] attached by task/demo/frame/camera/packet

Qwen does not define edges. It is compatible with edge v2 because edge repair preserves node slots. The exact corrected Qwen join is (packet_sha256, frame, camera_id, slot_id, bbox_xyxy_normalized).

The four source components are final in their own contracts. Do not launch joint training until the converted V3.0.7 package, legal-window census, normalization, model adapter/trainer and launch authority are released.

For live rollout today, use LiveGraphCoreExtractor plus the released real-time Qwen adapter. Full live structural_edges_v2 integration remains part of the pending V3.0.7 live converter; do not claim live edge-v2 parity before that gate closes.

Get and verify one complete final-source episode

After the Qwen ZIP tag below is published, this downloads only one matching episode plus the three strict loaders—no full-corpus checkout:

from huggingface_hub import snapshot_download
from pathlib import Path
import numpy as np
import sys

repo = "ChangChrisLiu/GWAM_Data"
task, demo = "TurnOnStove", "demo_9"

gp = "cosmos_policy_robocasa_v01_graph_core_v1_0_0_20260820"
ap = "cosmos_policy_robocasa_v01_articulation_edges_v2_v1_0_0_20260820"
qp = "cosmos_policy_robocasa_v01_qwen_v1_0_1_data_v1_0_0_20260821"

groot = Path(snapshot_download(
    repo_id=repo, repo_type="dataset",
    revision="cosmos-policy-robocasa-v01-graph-core-v1.0.0-20260820",
    local_dir="GWAM_final/graph",
    allow_patterns=[
        f"{gp}/EPISODE_INDEX.jsonl", f"{gp}/graph_core/**",
        f"{gp}/episodes/{task}/{demo}/graph_core.zip",
    ],
)) / gp
aroot = Path(snapshot_download(
    repo_id=repo, repo_type="dataset",
    revision="cosmos-policy-robocasa-v01-articulation-edges-v2-v1.0.0-20260820",
    local_dir="GWAM_final/articulation",
    allow_patterns=[
        f"{ap}/EPISODE_INDEX.jsonl", f"{ap}/articulation_edges_v2/**",
        f"{ap}/episodes/{task}/{demo}/articulation_edges_v2.zip",
    ],
)) / ap
qroot = Path(snapshot_download(
    repo_id=repo, repo_type="dataset",
    revision="cosmos-policy-robocasa-v01-qwen-v1.0.1-data-v1.0.0-20260821",
    local_dir="GWAM_final/qwen",
    allow_patterns=[
        f"{qp}/EPISODE_INDEX.jsonl", f"{qp}/qwen_data_release/**",
        f"{qp}/implementation/qwen_r2/**",
        f"{qp}/implementation/graph_adapter_qwen_frozen/**",
        f"{qp}/episodes/{task}/{demo}/qwen_v1_0_1_r2.zip",
    ],
)) / qp

sys.path.insert(0, str(groot))
from graph_core import load_episode as load_graph
sys.path.insert(0, str(aroot))
from articulation_edges_v2 import load_episode as load_articulation
sys.path.insert(0, str(qroot))
from qwen_data_release import load_release_zip

graph_zip = groot / f"episodes/{task}/{demo}/graph_core.zip"
graph = load_graph(graph_zip, verify_hashes=True)
art = load_articulation(
    aroot / f"episodes/{task}/{demo}", graph_core_zip=graph_zip,
)
qwen = load_release_zip(qroot / f"episodes/{task}/{demo}")

assert art.composition["status"] == "PASS"
assert qwen.receipt["task"] == task and qwen.receipt["demo"] == demo
assert len(qwen.arrays["frame_offsets.npy"]) - 1 == graph.pose.shape[0]

# Materialize camera-specific Qwen evidence on unchanged graph slots.
T, N = graph.pose.shape[:2]
f = qwen.arrays["frame.npy"].astype(np.int64)
c = qwen.arrays["camera_id.npy"].astype(np.int64)
s = qwen.arrays["slot_id.npy"].astype(np.int64)
e = qwen.arrays["embedding_mrl256.npy"]
assert np.all((0 <= f) & (f < T))
assert np.all((0 <= s) & (s < N))
assert np.all((0 <= c) & (c < 3))
linear_key = (f * N + s) * 3 + c
assert len(np.unique(linear_key)) == len(linear_key)
qwen_dense = np.zeros((T, N, 3, 256), dtype=np.float16)
qwen_valid = np.zeros((T, N, 3), dtype=bool)
qwen_dense[f, s, c] = e
qwen_valid[f, s, c] = True

print({
    "graph_pose": graph.pose.shape,
    "final_structural_edges": art.structural_edges_v2.shape,
    "qwen_embeddings": qwen.arrays["embedding_mrl256.npy"].shape,
    "qwen_dense": qwen_dense.shape,
    "qwen_valid_rows": int(qwen_valid.sum()),
    "composition": art.composition["status"],
})

Use art.structural_edges_v2 as final repaired topology; keep graph.contact_pairs as dynamic physical contact; attach qwen.arrays["embedding_mrl256.npy"] through the published packet/frame/camera/slot/bbox keys. Do not overwrite graph identities or topology with Qwen output.

Download the official model immutably—weights come from Qwen and are not duplicated in this dataset:

from huggingface_hub import snapshot_download

model_root = snapshot_download(
    repo_id="Qwen/Qwen3-VL-Embedding-2B",
    repo_type="model",
    revision="9f2f7e710d6d81056aa5c0a4f04764fec6bb7bda",
    local_dir="GWAM_final/models/Qwen3-VL-Embedding-2B",
)
print(model_root)

For fail-closed model allowlist/hash verification and live rollout, selectively download the Qwen package's scripts/download_pinned_qwen_model.py, realtime_qwen/**, implementation/**, and REALTIME_QWEN_WORKFLOW.md, then execute that workflow literally.

Released graph-core component

• agent-facing graph documentation index: cosmos_policy_robocasa_v01_graph_documentation_v1_0_2_20260820/README.md
• complete 24-task implementation table: cosmos_policy_robocasa_v01_graph_documentation_v1_0_2_20260820/TASK24_GRAPH_IMPLEMENTATION.md
• future joint-GWAM readiness handoff: cosmos_policy_robocasa_v01_graph_documentation_v1_0_2_20260820/JOINT_GWAM_READINESS_HANDOFF.md
• status/ambiguity resolutions: cosmos_policy_robocasa_v01_graph_documentation_v1_0_2_20260820/STATUS_AND_AMBIGUITY_RESOLUTION.md
• graph-core implementation map: cosmos_policy_robocasa_v01_graph_documentation_v1_0_2_20260820/GRAPH_CORE_IMPLEMENTATION_MAP.md
• graph-core + articulation composition guide: cosmos_policy_robocasa_v01_graph_documentation_v1_0_2_20260820/GRAPH_COMPOSITION_GUIDE.md
• immutable prefix: cosmos_policy_robocasa_v01_graph_core_v1_0_0_20260820
• immutable tag: cosmos-policy-robocasa-v01-graph-core-v1.0.0-20260820
• commit: d002356aa3d6341d80c006b68ac36c922ec4a25b
• coverage: 24 tasks / 1,320 demonstrations / 351,213 frames
• replay roles: 1,225 replay-success / 93 replay-failure / 2 skipped-too-short
• storage: 1,320 deterministic episode ZIPs, approximately 5.70 GB
• verification: complete manifest, per-episode receipts, strict loader, fresh-download tests, and live extraction smokes

Released articulation/edges v2 component

• immutable prefix: cosmos_policy_robocasa_v01_articulation_edges_v2_v1_0_0_20260820
• immutable tag: cosmos-policy-robocasa-v01-articulation-edges-v2-v1.0.0-20260820
• commit: 50c5899db0b2a15966cbb8dfc098c9f4ee1c6a20
• coverage: 24 tasks / 1,320 demonstrations / 351,213 frames
• storage: 1,320 deterministic episode ZIPs, 442,970,975 archive bytes
• final replay protocols: 860 render-free / 460 exact graph-protocol
• closure: 1,320/1,320 PASS, 0 quarantine, 0 non-bitwise attempts, 275/275 joint-control census rows byte-equal
• verification: 1,320 strict ZIP loads, complete manifest, source and packaged readbacks, exact-commit readback, fresh-tag tests and real examples
• post-publication evidence: cosmos_policy_robocasa_v01_articulation_edges_v2_docs_v1_0_0_20260820/HF_ARTICULATION_EDGES_V2_POSTPUBLICATION.json

This is an additive sidecar, not a replacement graph. Join it to graph core on exact (task,demo). Graph core owns identities, poses, targets, views, actions, contacts, and fixture state; articulation/edges v2 adds:

articulation_q_v2.npy       float32 [T,N,1] pose-phase articulation
articulation_valid_v2.npy   bool    [T,N,1] applicability/validity
qpos_v2.npy                 float32 [T,nq]  post-integration replay authority
structural_edges_v2.npy     int16   [E,3]   repaired structural edges
binding_table.json                              exact joint/control bindings

Phase rule: use articulation_q_v2 with same-frame graph-core pose; do not substitute qpos_v2, which is sampled one MuJoCo model substep later. qvel is gate-only and not published.

Minimal strict load:

from huggingface_hub import snapshot_download
from pathlib import Path
import sys

repo = "ChangChrisLiu/GWAM_Data"
prefix = "cosmos_policy_robocasa_v01_articulation_edges_v2_v1_0_0_20260820"
tag = "cosmos-policy-robocasa-v01-articulation-edges-v2-v1.0.0-20260820"
root = Path(snapshot_download(
    repo_id=repo, repo_type="dataset", revision=tag,
    local_dir="GWAM_Data_articulation",
    allow_patterns=[
        f"{prefix}/EPISODE_INDEX.jsonl",
        f"{prefix}/articulation_edges_v2/**",
        f"{prefix}/episodes/TurnOnStove/demo_9/articulation_edges_v2.zip",
    ],
)) / prefix
sys.path.insert(0, str(root))
from articulation_edges_v2 import load_episode
episode = load_episode(root / "episodes/TurnOnStove/demo_9")
print(
    episode.articulation_q_v2.shape,
    episode.qpos_v2.shape,
    episode.structural_edges_v2.shape,
)

For graph-core composition checks, pass the corresponding graph_core.zip to the component loader or run the component README example. The component package documents receipt/freeze dialects, superseded exclusions, exact joins, array semantics, and failure behavior in README.md, SCHEMA.md, and IMPLEMENTATION_MAP.md.

Each graph-core episode stores:

identity:       slot_id, family_id, static_flags [N,2], node_names, node_families
state:          pose [T,N,7], pose_valid [T,N]
task:           is_task_target [N]
three views:    view_evidence [T,N,3,8], view_record_valid [T,N,3]
actions:        actions_raw12 [T,12], actions_policy7 [T,7]
alignment:      source_action_index [T], sim_time [T], packet_sha256 [T]
physics:        contact_offsets [T+1], contact_pairs [K,2]
fixture state:  fixture_state [T,2], fixture_state_valid [T,2]
structure:      structural_edges [E,3] (historical graph-core relation set)

Actions are separate from graph features. Graph frame t is captured before action a_t; a_t causes the transition toward the next state. Right, left, and wrist camera records remain separate measurements of one physical graph—never three independent graphs.

Contact versus holding

Physical contact is included. contact_pairs.npy plus contact_offsets.npy stores the unique unordered node-slot contact pairs for every frame. A combined robot↔task-target contact flag can be derived exactly from the released graph:

import numpy as np

frame = 0
pairs = episode.contacts_at(frame)
robot_slots = set(np.flatnonzero(episode.node_families == "robot").tolist())
target_slots = set(np.flatnonzero(episode.is_task_target).tolist())
robot_target_contact = any(
    (int(a) in robot_slots and int(b) in target_slots)
    or (int(b) in robot_slots and int(a) in target_slots)
    for a, b in pairs
)

Full-corpus readback finds combined robot↔target physical contact in 1,313/1,320 episodes and 132,517/351,213 graph frames.

This is a lower bound on physical target touching. Two successful control episodes (TurnOffMicrowave/demo_6 and TurnOffSinkFaucet/demo_34) have zero combined robot↔target contact because the touched geom maps to a housing/parent slot rather than the target component slot. Geom-level finger contact is required to resolve that undercount.

This signal has a strict boundary:

• the stored robot node collapses contacts from robot geometries mapped through robot0_right_hand or robot0_base ancestry;
• therefore it represents combined robot-body contact, not guaranteed gripper/finger-only contact;
• contact pairs do not retain the original contact geom, finger identity, force, normal, or contact point;
• the released graph has no explicit holding, holds, held_by, gripper_target_contact, or grasp-state field;
• generic robot contact must not be relabeled as holding.

Exact gripper contact requires a new additive interaction sidecar derived from source MuJoCo contact geoms during replay. That sidecar is not part of the released graph-core data and must pass offline/live parity before any future package adopts it. It is optional enrichment and is not a V3.0.7-compat requirement. The authoritative sidecar should store left-finger, right-finger, other-robot, and both-finger contact plus validity—not a guessed semantic holding label.

The graph-core component deliberately excludes embedded articulation, RGB blobs, crop records, Qwen embeddings, explicit holding/grasp labels, checkpoints, and evaluation results. Articulation is released as the separately authenticated additive component above. Graph core alone is a verified source component, not the final V3.0.7-compatible joint-training package.

Download and inspect one episode

from huggingface_hub import snapshot_download
from pathlib import Path
import sys

repo = "ChangChrisLiu/GWAM_Data"
prefix = "cosmos_policy_robocasa_v01_graph_core_v1_0_0_20260820"
revision = "cosmos-policy-robocasa-v01-graph-core-v1.0.0-20260820"

root = Path(snapshot_download(
    repo_id=repo,
    repo_type="dataset",
    revision=revision,
    local_dir="GWAM_Data",
    allow_patterns=[
        f"{prefix}/README.md",
        f"{prefix}/SCHEMA.md",
        f"{prefix}/EPISODE_INDEX.jsonl",
        f"{prefix}/graph_core/**",
        f"{prefix}/live_evaluation/**",
        f"{prefix}/episodes/PnPCounterToCab/demo_1/graph_core.zip",
    ],
)) / prefix

sys.path.insert(0, str(root))
from graph_core import load_episode

episode = load_episode(
    root / "episodes/PnPCounterToCab/demo_1/graph_core.zip",
    verify_hashes=True,
)
print(episode.pose.shape)           # [T,N,7]
print(episode.view_evidence.shape)  # [T,N,3,8]
print(episode.actions_policy7.shape)

Online evaluation graphs

Packaged demonstrations are training/source data, not evaluation episodes. During evaluation, construct the graph from the current simulator state before every policy action:

# Continues from the download snippet above; the prefix is on sys.path.
# env is a freshly reset RoboCasa v0.1 environment.
from live_evaluation import LiveGraphCoreExtractor

extractor = LiveGraphCoreExtractor(env, task_name)
while not done:
    graph_t = extractor.capture()  # synchronized, capture-before-step
    action_t = policy(observation, graph_t)
    observation, reward, done, info = env.step(action_t)

The comparison protocol is fixed:

• object-instance split B
• base seeds 195, 196, 197
• 50 fresh trials per task per seed
• five layout/style pairs: (1,1), (2,2), (4,4), (6,9), (7,10)
• 10 trials per scene
• trial seed base_seed × episode_idx × 256
• one reset, task language read after reset, then 10 zero-action settling steps
• camera randomization disabled
• 24 × 50 × 3 = 3,600 total trials

No optimizer training, policy evaluation, or performance result is claimed by the data release.

2. Current final graph pattern — V3.0.7-compat

V3.0.7-compat is the frozen graph pattern for the current joint-training path. It means the Cosmos corpus will expose the same compact typed-graph semantics and production-loader interface expected by the joint model, while preserving RoboCasa v0.1 task/episode identities.

The final pattern is:

one simulator-authoritative physical graph G_t
+ three camera-indexed evidence panels
+ action a_t as a separate input
→ typed, validity-masked graph packet
→ relation-aware full-N graph processing
→ optional temporal L=8 history
→ action-conditioned future-graph supervision
→ fixed graph-token interface for joint training

Required graph semantics:

• variable active node count; padding is storage only
• stable node slots within each episode
• typed nodes and directed typed structural relations
• dynamic physical contacts represented separately
• pose, articulation, target, fixture state, and per-view validity masks
• right/left/wrist evidence preserved independently
• actions never inserted into node or edge features
• current and future graphs aligned by G_t, a_t → G_{t+1}
• future state used only as supervision, never as a current input

The released graph-core ZIPs and articulation sidecars are not yet V3.0.7-compatible training ZIPs. They are verified source components with separate contracts. Do not pass either component directly to the V3.0.7 joint-training loader until the conversion and production-loader gates close.

The planned materialized component is reserved as:

cosmos_policy_robocasa_v01_v307_compat_v1_0_0_<date>

It becomes RELEASED only after:

1. CLEARED: articulation/edges v2 closed over all 1,320 demonstrations and its immutable component is released;
2. every episode is converted to the frozen V3.0.7-compatible packet/window contract;
3. the production loader verifies identities, masks, targets, actions, first/last legal windows, and temporal boundaries;
4. exhaustive corpus readback, immutable tag readback, and fresh-download tests pass.

Gate (a) is cleared; gates (b/c)—conversion plus exhaustive production-loader/release readback—remain. Until they pass, the pattern is final but the 24-task V3.0.7-compatible artifact remains PENDING. No source component or partial conversion is presented as training-ready.

3. Current final Qwen pattern — v1.0.1

Qwen v1.0.1 is the correct frozen visual-semantic pattern for this corpus. Qwen supplies camera-specific evidence; it cannot add, remove, rename, or override a simulator-authoritative graph node or edge.

The first local Cosmos attempt labeled qwen_v1_0_1_full did not match the frozen crop and storage contract. It is stopped and permanently marked SUPERSEDED_DIAGNOSTIC_DO_NOT_RESUME_OR_PUBLISH; none of its 453 embeddings are reusable. The corrected implementation uses the new stage qwen_v1_0_1_r2.

Locate the complete implementation

• implementation prefix: cosmos_policy_robocasa_v01_qwen_v1_0_1_implementation_v1_0_0_20260820
• README.md: setup, status, gates, and literal commands
• SCHEMA.md: normative 12-array contract
• IMPLEMENTATION_MAP.md: file-by-file ownership
• qwen_r2/generator.py: decode, crop, dedup, embedding, atomic receipts
• qwen_r2/loader.py: strict files, joins, decoded RGB, crops, and norm replay
• graph_adapter_qwen_frozen/: hash-bound crop and model implementation
• examples/: inspect and regenerate one episode
• tests/: contract and failure-path tests
• validation/: cross-environment and real-GPU authorities

This prefix contains implementation, documentation, tests, and receipts only. It does not contain the 1,320 Qwen episode sidecars or duplicate model weights.

Frozen model and crop profile

model:                   Qwen/Qwen3-VL-Embedding-2B
model revision:          9f2f7e710d6d81056aa5c0a4f04764fec6bb7bda
model dtype/attention:   bfloat16 / SDPA
source → stored width:   2048 → 256
stored embedding:        float16, finite, unit norm within 1e-3
instruction:             Represent this RoboCasa graph image region.
camera ids:              0 right / 1 left / 2 wrist
crop context:            12% independently on each axis
minimum crop side:       16 pixels by box expansion, never image resize
dedup scope:             (camera_id, crop_rgb_sha256) within one episode
row order:               frame, camera_id, slot_id

Crop construction is exact:

1. authenticate the stored JPEG bytes;
2. decode to contiguous uint8 [H,W,3] RGB;
3. expand normalized width and height independently by 12% on each side;
4. enforce a 16-pixel minimum by expanding the box;
5. shift/clamp the box inside the frame, then floor starts and ceil ends;
6. slice raw HWC pixels without resizing or JPEG re-encoding;
7. hash canonical {dtype, shape, layout=HWC_RGB} JSON, a NUL byte, and raw contiguous bytes;
8. pass Image.fromarray(raw_crop) to the pinned model.

JPEG decoding is pinned by output. decoded_rgb_sha256.npy [T×3] records one canonical raw-HWC hash for every frame and camera. A consumer must reproduce those hashes before recomputing crops or embeddings. Decoder package versions are provenance only. The verified generation class is libjpeg-turbo with JPEG ABI 6.2; WDG and RoboCasa independently reproduce the same 300-row/six-family authority.

Corrected sidecar arrays

For T graph frames and M valid node-camera rows:

frame_offsets.npy          int64   [T+1]
frame.npy                  int32   [M]
source_frame.npy           int32   [M]
camera_id.npy              uint8   [M]
slot_id.npy                int16   [M]
bbox_xyxy_normalized.npy   float32 [M,4]
embedding_mrl256.npy       float16 [M,256]
packet_sha256.npy          U64     [M]
crop_rgb_sha256.npy        U64     [M]
rgb_sha256.npy             U64     [M]
unique_index.npy           int32   [M]
decoded_rgb_sha256.npy     U64     [T×3]

The exact source-row join is:

(packet_sha256, frame, camera_id, slot_id, bbox_xyxy_normalized)

The superseded JPEG-crop hash is not a join key. Deduplication reduces model inference only; every valid source row remains present.

Verified examples

Download the implementation:

from huggingface_hub import snapshot_download

repo = "ChangChrisLiu/GWAM_Data"
prefix = "cosmos_policy_robocasa_v01_qwen_v1_0_1_implementation_v1_0_0_20260820"
root = snapshot_download(
    repo_id=repo,
    repo_type="dataset",
    revision="cosmos-policy-robocasa-v01-qwen-v1.0.1-implementation-v1.0.0-20260820",
    local_dir="GWAM_Data",
    allow_patterns=[f"{prefix}/**"],
)
print(f"{root}/{prefix}")

Inspect one completed sidecar:

python examples/inspect_one_sidecar.py \
  /path/to/demo/qwen_v1_0_1_r2 \
  --source /path/to/matching/graph_rgb_demo

Regenerate one episode explicitly:

python examples/regenerate_one_episode.py \
  /path/to/graph_rgb_demo \
  --repo-root /path/to/gnn-world-model \
  --output /fresh/path/qwen_v1_0_1_r2

The packaged examples were executed with the real pinned model. Corrected PnP, double-door, and control GPU smokes passed; package tests passed in both WDG and RoboCasa environments.

Released corrected Qwen data

• data prefix: cosmos_policy_robocasa_v01_qwen_v1_0_1_data_v1_0_0_20260821
• immutable tag: cosmos-policy-robocasa-v01-qwen-v1.0.1-data-v1.0.0-20260821
• commit: 739f5ebecd8ee3f4142aed7ca977f3554f6e52ac
• coverage: 24 tasks / 1,320 episodes / 14,918,471 expanded rows
• unique inferences: 13,989,188
• episode ZIP bytes: 19,850,786,816 across 1,320 deterministic ZIP_STORED archives
• closure: 1,320/1,320 PASS, 24/24 task receipts PASS, 0 quarantine
• verification: 1,320 hardened ZIP loads, 48 source replays across all tasks, 28/28 package tests
• model: official Qwen/Qwen3-VL-Embedding-2B revision 9f2f7e710d6d81056aa5c0a4f04764fec6bb7bda; weights not duplicated
• real-time workflow: REALTIME_QWEN_WORKFLOW.md
• post-publication closure: HF_QWEN_ZIP_POSTPUBLICATION.json

The package README inside the immutable data tag is a manifest-sealed pre-upload snapshot and therefore says PASS_PREUPLOAD. It is preserved byte-exactly. This root README plus the linked post-publication receipt are the current RELEASED status authority; the tag resolves to the verified data commit above.

Download the complete corrected Qwen corpus from the immutable tag:

from huggingface_hub import snapshot_download

prefix = "cosmos_policy_robocasa_v01_qwen_v1_0_1_data_v1_0_0_20260821"
snapshot_download(
    repo_id="ChangChrisLiu/GWAM_Data",
    repo_type="dataset",
    revision="cosmos-policy-robocasa-v01-qwen-v1.0.1-data-v1.0.0-20260821",
    local_dir="GWAM_Qwen_v1_0_1",
    allow_patterns=[f"{prefix}/**"],
)

For one episode, use the complete selective download/load example near the top of this README. Each episode is one independently downloadable, authenticated ZIP.

The released data was regenerated uniformly under corrected r2. It does not reuse the 48 pilot sidecars or any of the 453 superseded diagnostics. Qwen v1.0.1 is the final camera/node semantic pattern for this source release. Training and policy evaluation were not started.

Released aligned RGB companion

• prefix: cosmos_policy_robocasa_v01_rgb_v1_0_0_20260821
• immutable tag: cosmos-policy-robocasa-v01-rgb-v1.0.0-20260821
• commit: 8657075fcf60980a49f02dccc65d084d57c062da
• coverage: 24 tasks / 1,320 episodes / 351,213 frames
• images: 1,053,639 JPEGs (right/left/wrist), uint8 [256,256,3] after verified decode
• JPEG bytes: 21,942,266,600
• episode ZIP bytes: 22,591,376,386 across 1,320 deterministic archives
• verification: 1,320 strict loads, 1,053,639 decoded-image hash/shape checks, PnP/door/control graph+Qwen joins
• post-publication closure: HF_RGB_POSTPUBLICATION.json

Download the complete RGB companion:

from huggingface_hub import snapshot_download

prefix = "cosmos_policy_robocasa_v01_rgb_v1_0_0_20260821"
snapshot_download(
    repo_id="ChangChrisLiu/GWAM_Data", repo_type="dataset",
    revision="cosmos-policy-robocasa-v01-rgb-v1.0.0-20260821",
    local_dir="GWAM_RGB_v1_0_0",
    allow_patterns=[f"{prefix}/**"],
)

Each episode exposes rgb_offsets, concatenated JPEG bytes, per-JPEG hashes, decoded-RGB hashes, graph packet hashes, source action indices and simulator times. Join by exact (task,demo,frame,camera_id,packet_sha256). Qwen embeddings remain separate node/camera semantics; they do not replace raw RGB.

The previous root README is preserved byte-for-byte at docs/archive/README_PRE_QWEN_V101_ALIGNMENT_ROOT_20260820.md.

---

Transition-aligned graph evaluation support (v1.0.0)

A new additive evaluation package binds predicted G[t+1] to the graph extracted after executing the same rollout action, while preserving separate GWAM/video and graph scorecards. It includes V3.0.7 structure/node/edge metrics, distinct fixed-basis/private-latent Qwen contracts, a joint transition ledger, a 15-source literature map, two rendered illustrations, sample code, a concrete execution plan, and 42 executable tests.

• Open the evaluation README
• Read the concrete evaluation plan
• Read the Fable Max scientific review
• Run the validated example

Status boundary: this is executable evaluation infrastructure, not a new GWAM model-performance result.