Publish Xperience-10M task-suite derived artifacts

DATA_NOTICE.md

@@ -1,6 +1,6 @@
 # Data Notice
 
-This repository does not redistribute raw Ropedia / Xperience-10M data.
+This repository does not redistribute raw Xperience-10M data.
 
 To reproduce the experiments, download the public sample from Hugging Face:
 
@@ -22,4 +22,4 @@ stereo_left.mp4
 stereo_right.mp4
 ```
 
-Use of the dataset is governed by the original Ropedia / Xperience-10M dataset terms.
+Use of the dataset is governed by the original Xperience-10M dataset terms.

PROJECT_README.md

@@ -1,12 +1,12 @@
-# Ropedia Episode Task Suite
+# Xperience-10M Episode Task Suite
 
 [![Website](https://img.shields.io/badge/site-GitHub%20Pages-1f63e9)](https://chaoyue0307.github.io/ropedia-episode-task-suite/)
 [![HF Space](https://img.shields.io/badge/Hugging%20Face-Space-ffb000)](https://huggingface.co/spaces/cy0307/ropedia-episode-task-suite)
-[![Dataset](https://img.shields.io/badge/dataset-Ropedia%20%2F%20Xperience--10M-008b9a)](https://github.com/Ropedia)
+[![Dataset](https://img.shields.io/badge/dataset-Xperience--10M%20by%20Ropedia-008b9a)](https://github.com/Ropedia)
 [![Scope](https://img.shields.io/badge/scope-single%20public%20sample-b65b04)](#scope)
 
-An audit-first embodied-AI learning repo built around one public Ropedia /
-Xperience-10M sample episode.
+An audit-first embodied-AI learning repo built around one public
+Xperience-10M sample episode released by Ropedia.
 
 The project does one narrow thing carefully: it turns a raw multimodal episode
 into:
@@ -58,7 +58,7 @@ Hugging Face Space app:
 | Derived artifacts on Hugging Face | https://huggingface.co/datasets/cy0307/ropedia-episode-task-suite-artifacts |
 | Minimal baseline models on Hugging Face | https://huggingface.co/cy0307/ropedia-minimal-task-baselines |
 | Hugging Face collection | https://huggingface.co/collections/cy0307/ropedia-episode-task-suite |
-| Ropedia website | https://ropedia.com/dataset |
+| Xperience-10M dataset website | https://ropedia.com/dataset |
 | Xperience-10M release page | https://ropedia.com/blog/20260316_xperience_10m |
 | Ropedia GitHub organization | https://github.com/Ropedia |
 | HOMIE Toolkit | https://github.com/Ropedia/HOMIE-toolkit |
@@ -66,7 +66,7 @@ Hugging Face Space app:
 | Xperience-10M sample on Hugging Face | https://huggingface.co/datasets/ropedia-ai/xperience-10m-sample |
 | Ropedia Hugging Face organization | https://huggingface.co/ropedia-ai |
 
-![ChatGPT-image-backed 12-task infographic](docs/assets/task_suite_infographic.png?v=bb2beb9)
+![ChatGPT-image-backed Xperience-10M 12-task infographic](docs/assets/task_suite_infographic.png?v=xperience10m)
 
 The infographic uses a ChatGPT-image-generated text-free research background and
 low-resolution modality thumbnails extracted from the public sample episode. The
@@ -76,9 +76,9 @@ with [`scripts/render_task_suite_infographic.py`](scripts/render_task_suite_info
 so the published PNG is a presentation graphic with verified labels and metrics,
 not a hallucinated metric sheet.
 
-![Verified Pipeline](docs/assets/pipeline_diagram.png?v=bb2beb9)
+![Verified Pipeline](docs/assets/pipeline_diagram.png?v=xperience10m)
 
-![Minimal 12-task model architectures](docs/assets/task_architectures.png?v=bb2beb9)
+![Minimal 12-task model architectures](docs/assets/task_architectures.png?v=xperience10m)
 
 The pipeline and architecture figures use the same pattern: ChatGPT-image
 provides text-free visual backgrounds, while
@@ -102,6 +102,11 @@ scripts/
   generate_visualizations.py        # refreshes SVG charts + summary JSON
   render_task_suite_infographic.py  # renders the ChatGPT-image-backed PNG
   render_overview_figures.py        # renders polished pipeline/architecture PNGs
+  omni/
+    download_sample_modelscope.py   # mainland-China friendly sample download
+    build_episode_manifest.py       # metadata-only multi-episode scanner
+    plan_finetune_sample_budget.py  # H20 storage/sample-count planner
+    qwen3_omni_adapter_smoke.py     # real-data Qwen3-Omni adapter smoke test
 
 results/
   min_action_model/                 # motion-only action baseline artifacts
@@ -109,6 +114,7 @@ results/
   min_all_modalities_action_model/  # current all-feature action artifacts
   min_all_modalities_subtask_model/ # current all-feature subtask artifacts
   episode_task_suite/               # 12-task suite metrics and predictions
+  omni_exploration/                 # H20/ModelScope smoke-test artifacts
 
 docs/
   index.html                        # GitHub Pages dashboard
@@ -124,12 +130,13 @@ notes/
   episode_task_suite.md
 ```
 
-Raw Ropedia data is **not** committed. Download it from the original source and
-follow the dataset terms.
+Raw Xperience-10M data is **not** committed. Download it from the official
+Ropedia distribution and follow the dataset terms.
 
 ## Data Expected
 
-The scripts expect a workspace with the Ropedia toolkit and the sample episode:
+The scripts expect a workspace with the Ropedia HOMIE toolkit and the
+Xperience-10M sample episode:
 
 ```text
 <workspace>/
@@ -175,6 +182,18 @@ hf download ropedia-ai/xperience-10m-sample \
   --local-dir data/sample/xperience-10m-sample
 ```
 
+On mainland-China servers, use ModelScope instead:
+
+```bash
+python scripts/omni/download_sample_modelscope.py \
+  --output-dir data/sample/xperience-10m-sample \
+  --mode minimal
+```
+
+`--mode minimal` downloads `annotation.hdf5`, `README.md`, and
+`fisheye_cam0.mp4`. Use `--mode all-training` to add all six MP4 streams while
+still skipping `visualization.rrd`.
+
 Clone and run this repo:
 
 ```bash
@@ -190,6 +209,86 @@ python scripts/train_min_action_model.py --workspace /path/to/workspace
 python scripts/train_all_modalities_model.py --workspace /path/to/workspace
 ```
 
+## Xperience-10M Fine-Tuning Exploration On H20
+
+This repo now includes a concrete first step toward a Qwen3-Omni fine-tuning
+pipeline over Xperience-10M. The important separation is:
+
+- direct Qwen3-Omni inputs: RGB/fisheye video, embedded MP4 audio, and language
+  prompts,
+- adapter-required Xperience-10M sensor inputs: depth, pose/SLAM, hand/body
+  mocap, contacts, and IMU.
+
+The H20 smoke test validates the adapter-required side first, using real
+Xperience-10M sample data from ModelScope and real action labels. It does not
+download or fine-tune the 30B Qwen3-Omni weights yet.
+
+```bash
+python scripts/omni/build_episode_manifest.py \
+  --data-root /home/cy/Ropedia/modelscope_data \
+  --output outputs/omni_exploration/modelscope_manifest.json
+
+python scripts/omni/qwen3_omni_adapter_smoke.py \
+  --workspace /home/cy/Ropedia/ropedia-episode-task-suite \
+  --episode-root /home/cy/Ropedia/modelscope_data/xperience-10m-sample \
+  --target action \
+  --window-frames 20 \
+  --stride-frames 100 \
+  --max-windows-per-episode 64 \
+  --epochs 2 \
+  --skip-video-features
+```
+
+Verified H20 run:
+
+| Item | Value |
+| --- | ---: |
+| Server | 8 x NVIDIA H20, 96GB each |
+| Free storage checked | about 1.5TB under `/home/cy` |
+| Data source | ModelScope `ropedia-ai/xperience-10m-sample` |
+| Downloaded minimal data | 1.93GB `annotation.hdf5` + 85.7MB `fisheye_cam0.mp4` |
+| Smoke windows | 59 |
+| Split | single-episode chronological |
+| Feature dim | 4,262 |
+| Adapter soft-token blocks | 11 |
+| Qwen3-Omni weights loaded | no |
+| Result | 0.0000 macro-F1, expected for this single-episode chronological smoke split |
+
+The zero score is not treated as a model claim. It is a useful signal that this
+split is not leaking labels across time: the train segment does not cover every
+action that appears in the held-out segment. The next real step is to add more
+episodes and split by held-out episode.
+
+### Sample Count Decision
+
+The local Mac sample is only one episode. For H20 fine-tuning, decide sample
+count by storage and evaluation design, not by the local folder. The current H20
+has about 1.5TB free under `/home/cy`; after reserving space for model weights,
+checkpoints, caches, and logs, a realistic first budget is:
+
+| Phase | Episodes/samples | Approx windows at stride 5 | Purpose |
+| --- | ---: | ---: | --- |
+| Smoke | 1-3 | 1k-3k | Verify loaders, token alignment, and task heads |
+| Pilot | 16-32 | 18k-37k | First held-out-episode evaluation |
+| Useful LoRA run | 64-128 | 74k-149k | Train sensor adapters plus selected Qwen3-Omni LoRA |
+| Storage-heavy run | 256+ | 297k+ | Only after download layout and checkpoint size are stable |
+
+For the next run, use **32 episodes** if ModelScope exposes enough files
+cleanly. If download structure is simple and disk remains above 800GB free,
+scale to **64 or 128 episodes**. Do not aim for 10k samples first; at the
+observed sample-equivalent size, that would become a data-management project
+before it is a modeling experiment.
+
+Use the budget helper before downloading:
+
+```bash
+python scripts/omni/plan_finetune_sample_budget.py \
+  --storage-root /home/cy \
+  --target-free-after-download-gb 800 \
+  --all-training-per-episode-gb 2.4 \
+  --full-preview-per-episode-gb 5.1
+```
+
 Refresh charts and the website data bundle:
 
 ```bash
@@ -297,7 +396,7 @@ The exact feature block boundaries are stored in
 
 ## Data Notice
 
-Ropedia / Xperience-10M data belongs to its original authors and is subject to
-the dataset's original license and access terms. This repo contains code and
+Xperience-10M data belongs to its original authors and is subject to the
+official Ropedia dataset license and access terms. This repo contains code and
 derived experiment artifacts only; it does not redistribute the raw videos or
 raw annotation dataset.

README.md

@@ -1,6 +1,6 @@
 ---
 license: other
-pretty_name: Ropedia Episode Task Suite Artifacts
+pretty_name: Xperience-10M Episode Task Suite Artifacts
 tags:
   - robotics
   - embodied-ai
@@ -20,11 +20,11 @@ size_categories:
   - n<1K
 ---
 
-# Ropedia Episode Task Suite Artifacts
+# Xperience-10M Episode Task Suite Artifacts
 
-This dataset repo contains the derived evidence layer for the public Ropedia / Xperience-10M sample episode: metrics, predictions, manifests, charts, diagrams, notes, and reproduction scripts.
+This dataset repo contains the derived evidence layer for the public Xperience-10M sample episode released by Ropedia: metrics, predictions, manifests, charts, diagrams, notes, and reproduction scripts.
 
-It does **not** contain raw Ropedia videos or raw `annotation.hdf5`. Download raw data only from the official Ropedia / Hugging Face sources and follow their terms.
+It does **not** contain raw Xperience-10M videos or raw `annotation.hdf5`. Download raw data only from the official Ropedia / Hugging Face sources and follow their terms.
 
 ## Why This Repo Exists
 
@@ -54,7 +54,7 @@ https://huggingface.co/cy0307/ropedia-minimal-task-baselines
 | Minimal model repo | https://huggingface.co/cy0307/ropedia-minimal-task-baselines |
 | GitHub repo | https://github.com/ChaoYue0307/ropedia-episode-task-suite |
 | GitHub Pages dashboard | https://chaoyue0307.github.io/ropedia-episode-task-suite/ |
-| Ropedia website | https://ropedia.com/dataset |
+| Xperience-10M website | https://ropedia.com/dataset |
 | Xperience-10M release page | https://ropedia.com/blog/20260316_xperience_10m |
 | Ropedia GitHub organization | https://github.com/Ropedia |
 | HOMIE Toolkit | https://github.com/Ropedia/HOMIE-toolkit |

docs/index.html

@@ -3,9 +3,9 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Ropedia Episode Task Suite</title>
-  <meta name="description" content="A transparent multimodal task suite for one public Ropedia / Xperience-10M sample episode.">
-  <meta property="og:title" content="Ropedia Episode Task Suite">
+  <title>Xperience-10M Episode Task Suite</title>
+  <meta name="description" content="A transparent multimodal task suite for one public Xperience-10M sample episode released by Ropedia.">
+  <meta property="og:title" content="Xperience-10M Episode Task Suite">
   <meta property="og:description" content="One public embodied-AI episode, converted into reproducible multimodal tasks, baselines, metrics, and diagrams.">
   <meta property="og:image" content="assets/task_suite_infographic.png?v=bb2beb9">
   <style>
@@ -487,9 +487,9 @@
   <a class="skip-link" href="#main">Skip to content</a>
   <nav class="site-nav">
     <div class="wrap nav-inner">
-      <a class="brand" href="#top" aria-label="Ropedia Episode Task Suite home">
-        <span class="mark" aria-hidden="true">R</span>
-        <span>Ropedia Episode Task Suite</span>
+      <a class="brand" href="#top" aria-label="Xperience-10M Episode Task Suite home">
+        <span class="mark" aria-hidden="true">X</span>
+        <span>Xperience-10M Episode Task Suite</span>
       </a>
       <div class="nav-links" aria-label="Page navigation">
         <a href="#suite">Suite</a>
@@ -509,9 +509,9 @@
     <div class="wrap hero-inner">
       <div>
         <div class="eyebrow">single public episode / verified artifacts</div>
-        <h1>One Ropedia episode, made auditable.</h1>
+        <h1>One Xperience-10M episode, made auditable.</h1>
         <p class="hero-copy">
-          A compact research lab for the public Ropedia / Xperience-10M sample:
+          A compact research lab for the public Xperience-10M sample from Ropedia:
           video, audio, depth, pose, motion capture, inertial sensing, and language annotation,
           with an explicit record of which modalities enter the current minimal feature vector.
         </p>
@@ -547,10 +547,10 @@
     <section id="suite">
       <div class="wrap">
         <div class="section-head">
-          <h2>Ropedia 12-task suite, first.</h2>
+          <h2>Xperience-10M 12-task suite, first.</h2>
           <p>The top-level map shows the Xperience-10M sample modalities and the verified 12-task results. Audio is present in the sample MP4 stream, but the current 8,378-d baseline manifest does not featurize it.</p>
         </div>
-        <img class="task-suite-image" src="assets/task_suite_infographic.png?v=bb2beb9" alt="ChatGPT-image-backed infographic showing all 12 Ropedia episode tasks">
+        <img class="task-suite-image" src="assets/task_suite_infographic.png?v=xperience10m" alt="ChatGPT-image-backed infographic showing all 12 Xperience-10M episode tasks">
       </div>
     </section>
 
@@ -560,11 +560,11 @@
           <h2>From raw episode to checked artifacts.</h2>
           <p>Every script works from one data contract: aligned multimodal windows, explicit labels, cached feature extraction, and a manifest that makes omitted modalities visible.</p>
         </div>
-        <img class="pipeline-image" src="assets/pipeline_diagram.png?v=bb2beb9" alt="Verified Ropedia multimodal pipeline diagram">
+        <img class="pipeline-image" src="assets/pipeline_diagram.png?v=xperience10m" alt="Verified Xperience-10M multimodal pipeline diagram">
         <div class="callout-row">
           <div class="callout">
             <h3>What this project proves</h3>
-            <p>It proves the full engineering loop: reading Ropedia sample data, aligning modalities, converting them into model-ready windows, defining meaningful tasks, producing metrics, and packaging every artifact for review.</p>
+            <p>It proves the full engineering loop: reading Xperience-10M sample data, aligning modalities, converting them into model-ready windows, defining meaningful tasks, producing metrics, and packaging every artifact for review.</p>
           </div>
           <div class="callout">
             <h3>What it does not prove</h3>
@@ -596,7 +596,7 @@
           <h2>The 12 tasks share four head families.</h2>
           <p>The diagram separates the shared episode-window feature pipeline from the task-specific heads, and notes that audio remains dataset context rather than a current baseline feature block.</p>
         </div>
-        <img class="architecture-image" src="assets/task_architectures.png?v=bb2beb9" alt="Verified minimal architecture diagram for all 12 Ropedia episode tasks">
+        <img class="architecture-image" src="assets/task_architectures.png?v=xperience10m" alt="Verified minimal architecture diagram for all 12 Xperience-10M episode tasks">
       </div>
     </section>
 
@@ -667,7 +667,7 @@
           <article class="artifact"><h3>Windows table</h3><p>Window start/end frames and aligned action/subtask labels.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/episode_task_suite/windows.csv">windows.csv</a></article>
           <article class="artifact"><h3>Reproduction scripts</h3><p>Three training scripts plus the dashboard generator.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/tree/main/scripts">scripts/</a></article>
           <article class="artifact"><h3>Hugging Face Space</h3><p>The same dashboard packaged as a public static Space.</p><a href="https://huggingface.co/spaces/cy0307/ropedia-episode-task-suite">cy0307/ropedia-episode-task-suite</a></article>
-          <article class="artifact"><h3>Derived HF artifacts</h3><p>Metrics, predictions, docs, and lightweight derived files without raw Ropedia video/data redistribution.</p><a href="https://huggingface.co/datasets/cy0307/ropedia-episode-task-suite-artifacts">dataset repo</a></article>
+          <article class="artifact"><h3>Derived HF artifacts</h3><p>Metrics, predictions, docs, and lightweight derived files without raw Xperience-10M video/data redistribution.</p><a href="https://huggingface.co/datasets/cy0307/ropedia-episode-task-suite-artifacts">dataset repo</a></article>
           <article class="artifact"><h3>HF baseline models</h3><p>Minimal NumPy softmax and ridge baseline weights with model card and architecture diagrams.</p><a href="https://huggingface.co/cy0307/ropedia-minimal-task-baselines">model repo</a></article>
           <article class="artifact"><h3>HF collection</h3><p>Space, artifacts, and model baselines grouped into one public project collection.</p><a href="https://huggingface.co/collections/cy0307/ropedia-episode-task-suite">collection</a></article>
         </div>
@@ -678,7 +678,7 @@
       <div class="wrap">
         <div class="section-head">
           <h2>Reproduce the suite.</h2>
-          <p>Raw Ropedia data is not redistributed here. Download the public sample separately, then run the same scripts.</p>
+          <p>Raw Xperience-10M data is not redistributed here. Download the public sample separately, then run the same scripts.</p>
         </div>
         <pre class="code-panel"><button type="button" data-copy="setup">Copy</button><code id="setup">git clone https://github.com/Ropedia/HOMIE-toolkit.git
 python3.12 -m venv .venv

notes/episode_task_suite.md

@@ -6,7 +6,7 @@ Script:
 scripts/episode_task_suite.py
 ```
 
-This script turns the single public Ropedia sample episode into many end-to-end tasks. It is designed for learning, debugging, and task design. It is **not** a generalization benchmark because the data is still one episode.
+This script turns the single public Xperience-10M sample episode into many end-to-end tasks. It is designed for learning, debugging, and task design. It is **not** a generalization benchmark because the data is still one episode.
 
 Run:
 

notes/min_action_model.md

@@ -1,6 +1,6 @@
 # Minimal Action Model
 
-This is the first modeling baseline for the Ropedia/Xperience sample.
+This is the first modeling baseline for the public Xperience-10M sample released by Ropedia.
 
 The script is:
 

notes/reproducibility_audit.md

@@ -2,7 +2,7 @@
 
 Audit date: 2026-05-30 Asia/Singapore.
 
-Purpose: verify that the committed Ropedia Episode Task Suite artifacts are
+Purpose: verify that the committed Xperience-10M Episode Task Suite artifacts are
 real outputs from the scripts, not placeholder or fabricated metrics.
 
 ## Raw Inputs Checked

results/omni_exploration/modelscope_manifest.json

@@ -0,0 +1,66 @@
+{
+  "summary": {
+    "num_episodes": 1,
+    "total_bytes": 2021338279,
+    "train_minimal_bytes": 2021338279,
+    "notes": [
+      "train_minimal_bytes excludes visualization.rrd because model training does not need it.",
+      "This file is metadata-only; it does not copy or download raw data."
+    ]
+  },
+  "episodes": [
+    {
+      "episode_id": "xperience-10m-sample",
+      "path": "/home/cy/Ropedia/modelscope_data/xperience-10m-sample",
+      "annotation": "/home/cy/Ropedia/modelscope_data/xperience-10m-sample/annotation.hdf5",
+      "files": [
+        {
+          "name": "annotation.hdf5",
+          "bytes": 1931496028,
+          "exists": true
+        },
+        {
+          "name": "fisheye_cam0.mp4",
+          "bytes": 89842251,
+          "exists": true
+        },
+        {
+          "name": "fisheye_cam1.mp4",
+          "bytes": 0,
+          "exists": false
+        },
+        {
+          "name": "fisheye_cam2.mp4",
+          "bytes": 0,
+          "exists": false
+        },
+        {
+          "name": "fisheye_cam3.mp4",
+          "bytes": 0,
+          "exists": false
+        },
+        {
+          "name": "stereo_left.mp4",
+          "bytes": 0,
+          "exists": false
+        },
+        {
+          "name": "stereo_right.mp4",
+          "bytes": 0,
+          "exists": false
+        },
+        {
+          "name": "visualization.rrd",
+          "bytes": 0,
+          "exists": false
+        }
+      ],
+      "total_bytes": 2021338279,
+      "train_minimal_bytes": 2021338279,
+      "has_annotation": true,
+      "has_any_video": true,
+      "has_all_videos": false,
+      "has_rrd": false
+    }
+  ]
+}

results/omni_exploration/qwen3_adapter_smoke/RUN_REPORT.md

@@ -0,0 +1,15 @@
+# Qwen3-Omni Adapter Smoke Test
+
+- Base model target: `Qwen/Qwen3-Omni-30B-A3B-Thinking`
+- Qwen3-Omni weights loaded: `false`
+- Episodes: `1`
+- Windows: `59` total, `41` train, `18` test
+- Split: `single_episode_chronological`
+- Feature dimension: `4262`
+- Adapter soft-token blocks: `11`
+- Accuracy: `0.0000`
+- Macro-F1: `0.0000`
+
+## Why this is the minimum real test
+
+This run uses real Ropedia annotation/video-derived feature blocks. It tests the sensor-adapter side that depth, pose, mocap, contacts, and IMU need before those tokens are attached to Qwen3-Omni. It deliberately avoids downloading the 30B Qwen3-Omni weights until the data path, labels, splits, and storage plan are confirmed.

results/omni_exploration/qwen3_adapter_smoke/adapter_blocks.json

@@ -0,0 +1,68 @@
+[
+  {
+    "name": "hand_left_joints",
+    "start": 0,
+    "end": 441,
+    "dim": 441
+  },
+  {
+    "name": "hand_right_joints",
+    "start": 441,
+    "end": 882,
+    "dim": 441
+  },
+  {
+    "name": "body_joints",
+    "start": 882,
+    "end": 1974,
+    "dim": 1092
+  },
+  {
+    "name": "body_contacts",
+    "start": 1974,
+    "end": 2121,
+    "dim": 147
+  },
+  {
+    "name": "camera_translation",
+    "start": 2121,
+    "end": 2142,
+    "dim": 21
+  },
+  {
+    "name": "camera_rotation_matrix",
+    "start": 2142,
+    "end": 2205,
+    "dim": 63
+  },
+  {
+    "name": "imu_accel_gyro",
+    "start": 2205,
+    "end": 2247,
+    "dim": 42
+  },
+  {
+    "name": "depth_confidence",
+    "start": 2247,
+    "end": 3227,
+    "dim": 980
+  },
+  {
+    "name": "caption_objects_interaction_text",
+    "start": 3227,
+    "end": 4123,
+    "dim": 896
+  },
+  {
+    "name": "slam_point_cloud",
+    "start": 4123,
+    "end": 4145,
+    "dim": 22
+  },
+  {
+    "name": "calibration",
+    "start": 4145,
+    "end": 4262,
+    "dim": 117
+  }
+]

results/omni_exploration/qwen3_adapter_smoke/available_modalities.json

@@ -0,0 +1,34 @@
+[
+  {
+    "episode_id": "xperience-10m-sample",
+    "modalities": [
+      {
+        "modality": "depth_confidence",
+        "shape": [
+          5821,
+          140
+        ]
+      },
+      {
+        "modality": "caption_text",
+        "shape": [
+          5821,
+          128
+        ],
+        "fields": "objects,interaction"
+      },
+      {
+        "modality": "slam_point_cloud_static",
+        "shape": [
+          22
+        ]
+      },
+      {
+        "modality": "calibration_static",
+        "shape": [
+          117
+        ]
+      }
+    ]
+  }
+]

results/omni_exploration/qwen3_adapter_smoke/confusion_matrix.csv

@@ -0,0 +1,19 @@
+true\pred,Pick up kettle,Position kettle to pour,Move kettle,Hold coffee carafe,Grasp coffee scoop,Transfer coffee to dripper,Hold gooseneck kettle,Grasp gooseneck kettle,Lift gooseneck kettle,Move kettle away,Place kettle on table,Pick up white bottle,Pour liquid from white bottle,Close bottle cap,Place item on table,Wait/Prepare for pouring,Pour coffee,Pour milk into coffee
+Pick up kettle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Position kettle to pour,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Move kettle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Hold coffee carafe,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Grasp coffee scoop,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Transfer coffee to dripper,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Hold gooseneck kettle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Grasp gooseneck kettle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Lift gooseneck kettle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Move kettle away,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Place kettle on table,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Pick up white bottle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Pour liquid from white bottle,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+Close bottle cap,0,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0
+Place item on table,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0
+Wait/Prepare for pouring,2,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0
+Pour coffee,0,0,0,0,5,0,0,0,0,0,0,0,1,2,0,0,0,0
+Pour milk into coffee,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0

results/omni_exploration/qwen3_adapter_smoke/feature_manifest.json

@@ -0,0 +1,68 @@
+[
+  {
+    "name": "hand_left_joints",
+    "start": 0,
+    "end": 441,
+    "dim": 441
+  },
+  {
+    "name": "hand_right_joints",
+    "start": 441,
+    "end": 882,
+    "dim": 441
+  },
+  {
+    "name": "body_joints",
+    "start": 882,
+    "end": 1974,
+    "dim": 1092
+  },
+  {
+    "name": "body_contacts",
+    "start": 1974,
+    "end": 2121,
+    "dim": 147
+  },
+  {
+    "name": "camera_translation",
+    "start": 2121,
+    "end": 2142,
+    "dim": 21
+  },
+  {
+    "name": "camera_rotation_matrix",
+    "start": 2142,
+    "end": 2205,
+    "dim": 63
+  },
+  {
+    "name": "imu_accel_gyro",
+    "start": 2205,
+    "end": 2247,
+    "dim": 42
+  },
+  {
+    "name": "depth_confidence",
+    "start": 2247,
+    "end": 3227,
+    "dim": 980
+  },
+  {
+    "name": "caption_objects_interaction_text",
+    "start": 3227,
+    "end": 4123,
+    "dim": 896
+  },
+  {
+    "name": "slam_point_cloud",
+    "start": 4123,
+    "end": 4145,
+    "dim": 22
+  },
+  {
+    "name": "calibration",
+    "start": 4145,
+    "end": 4262,
+    "dim": 117
+  }
+]

results/omni_exploration/qwen3_adapter_smoke/metrics.json

@@ -0,0 +1,30 @@
+{
+  "task": "qwen3_omni_sensor_adapter_smoke_action",
+  "base_model_target": "Qwen/Qwen3-Omni-30B-A3B-Thinking",
+  "qwen3_loaded": false,
+  "qwen3_note": "This run validates Xperience-10M sensor-adapter tokens and task heads before loading or LoRA-tuning Qwen3-Omni.",
+  "split": "single_episode_chronological",
+  "num_episodes": 1,
+  "num_windows": 59,
+  "num_train_windows": 41,
+  "num_test_windows": 18,
+  "num_classes": 18,
+  "feature_dim": 4262,
+  "num_adapter_tokens": 11,
+  "accuracy": 0.0,
+  "macro_f1": 0.0,
+  "train_final_loss": 1.4479121318677577,
+  "train_final_accuracy": 0.6829268292682927,
+  "direct_qwen3_inputs": [
+    "rgb/fisheye video",
+    "embedded mp4 audio",
+    "language annotation prompt"
+  ],
+  "adapter_required_inputs": [
+    "depth/confidence",
+    "pose/SLAM camera trajectory",
+    "motion capture hand/body joints",
+    "IMU accel/gyro",
+    "contacts/object state features"
+  ]
+}

results/omni_exploration/qwen3_adapter_smoke/per_class_metrics.csv

@@ -0,0 +1,19 @@
+class_id,class_name,support,predicted,precision,recall,f1
+0,Pick up kettle,0,3,0.0,0.0,0.0
+1,Position kettle to pour,0,0,0.0,0.0,0.0
+2,Move kettle,0,0,0.0,0.0,0.0
+3,Hold coffee carafe,0,0,0.0,0.0,0.0
+4,Grasp coffee scoop,0,6,0.0,0.0,0.0
+5,Transfer coffee to dripper,0,0,0.0,0.0,0.0
+6,Hold gooseneck kettle,0,3,0.0,0.0,0.0
+7,Grasp gooseneck kettle,0,2,0.0,0.0,0.0
+8,Lift gooseneck kettle,0,0,0.0,0.0,0.0
+9,Move kettle away,0,0,0.0,0.0,0.0
+10,Place kettle on table,0,0,0.0,0.0,0.0
+11,Pick up white bottle,0,0,0.0,0.0,0.0
+12,Pour liquid from white bottle,0,2,0.0,0.0,0.0
+13,Close bottle cap,3,2,0.0,0.0,0.0
+14,Place item on table,2,0,0.0,0.0,0.0
+15,Wait/Prepare for pouring,4,0,0.0,0.0,0.0
+16,Pour coffee,8,0,0.0,0.0,0.0
+17,Pour milk into coffee,1,0,0.0,0.0,0.0

results/omni_exploration/qwen3_adapter_smoke/predictions.csv

@@ -0,0 +1,19 @@
+sample_index,episode_id,window_id,true_label,predicted_label,correct
+41,xperience-10m-sample,41,Close bottle cap,Pour liquid from white bottle,0
+42,xperience-10m-sample,42,Close bottle cap,Grasp gooseneck kettle,0
+43,xperience-10m-sample,43,Close bottle cap,Hold gooseneck kettle,0
+44,xperience-10m-sample,44,Place item on table,Grasp gooseneck kettle,0
+45,xperience-10m-sample,45,Place item on table,Pick up kettle,0
+46,xperience-10m-sample,46,Wait/Prepare for pouring,Hold gooseneck kettle,0
+47,xperience-10m-sample,47,Wait/Prepare for pouring,Pick up kettle,0
+48,xperience-10m-sample,48,Wait/Prepare for pouring,Hold gooseneck kettle,0
+49,xperience-10m-sample,49,Wait/Prepare for pouring,Pick up kettle,0
+50,xperience-10m-sample,50,Pour coffee,Grasp coffee scoop,0
+51,xperience-10m-sample,51,Pour coffee,Close bottle cap,0
+52,xperience-10m-sample,52,Pour coffee,Pour liquid from white bottle,0
+53,xperience-10m-sample,53,Pour coffee,Close bottle cap,0
+54,xperience-10m-sample,54,Pour coffee,Grasp coffee scoop,0
+55,xperience-10m-sample,55,Pour coffee,Grasp coffee scoop,0
+56,xperience-10m-sample,56,Pour coffee,Grasp coffee scoop,0
+57,xperience-10m-sample,57,Pour coffee,Grasp coffee scoop,0
+58,xperience-10m-sample,58,Pour milk into coffee,Grasp coffee scoop,0

scripts/episode_task_suite.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-End-to-end task suite for one Ropedia/Xperience episode.
+End-to-end task suite for one Xperience-10M episode released by Ropedia.
 
 The purpose is not to prove generalization from one sample episode. It is to
 turn the episode into multiple meaningful supervised/self-supervised learning
@@ -56,7 +56,7 @@ TASKS = [
 def parse_args() -> argparse.Namespace:
     workspace_default = Path(__file__).resolve().parents[1]
     annotation_default = workspace_default / "data/sample/xperience-10m-sample/annotation.hdf5"
-    parser = argparse.ArgumentParser(description="Run an end-to-end task suite on one Ropedia episode.")
+    parser = argparse.ArgumentParser(description="Run an end-to-end task suite on one Xperience-10M episode.")
     parser.add_argument("--workspace", type=Path, default=workspace_default)
     parser.add_argument("--annotation", type=Path, default=annotation_default)
     parser.add_argument("--output-dir", type=Path, default=workspace_default / "outputs/episode_task_suite")

scripts/generate_visualizations.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Generate static SVG visualizations and website data for the Ropedia task suite.
+Generate static SVG visualizations and website data for the Xperience-10M task suite.
 
 No plotting dependencies are required; this uses only the Python standard
 library so the repo stays easy to run.
@@ -117,7 +117,7 @@ def svg_pipeline_diagram(path: Path, summary: dict) -> None:
         f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}">',
         '<rect width="100%" height="100%" fill="#ffffff"/>',
         '<rect x="0" y="0" width="1400" height="760" fill="#ffffff"/>',
-        '<text x="60" y="58" font-family="Arial, sans-serif" font-size="32" font-weight="700" fill="#10141f">Verified Ropedia Episode Pipeline</text>',
+        '<text x="60" y="58" font-family="Arial, sans-serif" font-size="32" font-weight="700" fill="#10141f">Verified Xperience-10M Episode Pipeline</text>',
         '<text x="60" y="88" font-family="Arial, sans-serif" font-size="16" fill="#5b6475">Generated from committed scripts and metrics; no conceptual placeholder stages.</text>',
     ]
     arrows = [
@@ -324,7 +324,7 @@ def svg_task_architectures(path: Path, summary: dict) -> None:
         f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}">',
         '<defs><marker id="arrow2" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="#cbd5e1"/></marker></defs>',
         '<rect width="100%" height="100%" fill="#ffffff"/>',
-        '<text x="60" y="56" font-family="Arial, sans-serif" font-size="34" font-weight="700" fill="#10141f">Minimal Architectures for the 12 Ropedia Episode Tasks</text>',
+        '<text x="60" y="56" font-family="Arial, sans-serif" font-size="34" font-weight="700" fill="#10141f">Minimal Architectures for the 12 Xperience-10M Episode Tasks</text>',
         '<text x="60" y="88" font-family="Arial, sans-serif" font-size="16" fill="#5b6475">Generated from scripts/episode_task_suite.py semantics and committed summary metrics. These are minimal baselines, not deep foundation models.</text>',
     ]
 

scripts/omni/build_episode_manifest.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Build a lightweight manifest for local Xperience-10M episode folders.
+
+The manifest is intentionally metadata-only. It lets us decide how many
+episodes fit on the H20 server before downloading or copying large media.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+VIDEO_NAMES = [
+    "fisheye_cam0.mp4",
+    "fisheye_cam1.mp4",
+    "fisheye_cam2.mp4",
+    "fisheye_cam3.mp4",
+    "stereo_left.mp4",
+    "stereo_right.mp4",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Scan Xperience-10M episode folders.")
+    parser.add_argument(
+        "--data-root",
+        type=Path,
+        action="append",
+        required=True,
+        help="Root to scan. May be passed multiple times.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("outputs/omni_exploration/episode_manifest.json"),
+    )
+    parser.add_argument("--max-episodes", type=int, default=0, help="0 means no cap.")
+    return parser.parse_args()
+
+
+def size_or_zero(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except FileNotFoundError:
+        return 0
+
+
+def inspect_episode(annotation: Path) -> dict:
+    episode_dir = annotation.parent
+    files = [{"name": "annotation.hdf5", "bytes": size_or_zero(annotation), "exists": annotation.exists()}]
+    for name in VIDEO_NAMES:
+        path = episode_dir / name
+        files.append({"name": name, "bytes": size_or_zero(path), "exists": path.exists()})
+    rrd = episode_dir / "visualization.rrd"
+    files.append({"name": "visualization.rrd", "bytes": size_or_zero(rrd), "exists": rrd.exists()})
+    total_bytes = sum(item["bytes"] for item in files)
+    train_bytes = sum(item["bytes"] for item in files if item["name"] != "visualization.rrd")
+    return {
+        "episode_id": episode_dir.name,
+        "path": str(episode_dir),
+        "annotation": str(annotation),
+        "files": files,
+        "total_bytes": total_bytes,
+        "train_minimal_bytes": train_bytes,
+        "has_annotation": annotation.exists(),
+        "has_any_video": any((episode_dir / name).exists() for name in VIDEO_NAMES),
+        "has_all_videos": all((episode_dir / name).exists() for name in VIDEO_NAMES),
+        "has_rrd": rrd.exists(),
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    annotations: list[Path] = []
+    for root in args.data_root:
+        annotations.extend(sorted(root.expanduser().resolve().rglob("annotation.hdf5")))
+    if args.max_episodes > 0:
+        annotations = annotations[: args.max_episodes]
+
+    episodes = [inspect_episode(path) for path in annotations]
+    summary = {
+        "num_episodes": len(episodes),
+        "total_bytes": sum(ep["total_bytes"] for ep in episodes),
+        "train_minimal_bytes": sum(ep["train_minimal_bytes"] for ep in episodes),
+        "notes": [
+            "train_minimal_bytes excludes visualization.rrd because model training does not need it.",
+            "This file is metadata-only; it does not copy or download raw data.",
+        ],
+    }
+    payload = {"summary": summary, "episodes": episodes}
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(json.dumps(summary, indent=2))
+    print(f"Wrote {args.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/omni/download_sample_modelscope.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Download the public Xperience-10M sample from ModelScope.
+
+This is the preferred path for servers inside mainland China. It downloads
+only model-training files by default and skips visualization.rrd.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+DEFAULT_PATTERNS = [
+    "README.md",
+    "annotation.hdf5",
+    "fisheye_cam0.mp4",
+]
+
+ALL_TRAINING_PATTERNS = [
+    "README.md",
+    "annotation.hdf5",
+    "fisheye_cam0.mp4",
+    "fisheye_cam1.mp4",
+    "fisheye_cam2.mp4",
+    "fisheye_cam3.mp4",
+    "stereo_left.mp4",
+    "stereo_right.mp4",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Download Xperience-10M sample data from ModelScope.")
+    parser.add_argument("--repo-id", default="ropedia-ai/xperience-10m-sample")
+    parser.add_argument("--output-dir", type=Path, default=Path("data/sample/xperience-10m-sample"))
+    parser.add_argument(
+        "--mode",
+        choices=["minimal", "all-training", "all"],
+        default="minimal",
+        help="minimal downloads annotation + one video; all-training adds all MP4s; all also allows visualization.rrd.",
+    )
+    parser.add_argument("--max-workers", type=int, default=2)
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    from modelscope.hub.snapshot_download import snapshot_download
+
+    if args.mode == "minimal":
+        allow_patterns = DEFAULT_PATTERNS
+    elif args.mode == "all-training":
+        allow_patterns = ALL_TRAINING_PATTERNS
+    else:
+        allow_patterns = None
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    path = snapshot_download(
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        local_dir=str(args.output_dir),
+        allow_patterns=allow_patterns,
+        max_workers=args.max_workers,
+    )
+    summary = {
+        "repo_id": args.repo_id,
+        "output_dir": str(args.output_dir),
+        "mode": args.mode,
+        "allow_patterns": allow_patterns,
+        "download_path": path,
+    }
+    print(json.dumps(summary, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/omni/plan_finetune_sample_budget.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Plan Xperience-10M episode counts for an H20 fine-tuning run.
+
+This is a storage and evaluation-design helper. It does not train a model and
+does not invent results. Use it before downloading many episodes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import shutil
+from pathlib import Path
+
+
+GB = 1024 ** 3
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Estimate feasible Xperience-10M fine-tuning sample counts.")
+    parser.add_argument("--storage-root", type=Path, default=Path("/home/cy"), help="Disk root to inspect.")
+    parser.add_argument("--free-gb", type=float, default=None, help="Override measured free space in GiB.")
+    parser.add_argument("--target-free-after-download-gb", type=float, default=800.0)
+    parser.add_argument("--model-cache-gb", type=float, default=250.0)
+    parser.add_argument("--checkpoint-cache-gb", type=float, default=200.0)
+    parser.add_argument("--log-cache-gb", type=float, default=50.0)
+    parser.add_argument("--minimal-per-episode-gb", type=float, default=2.02)
+    parser.add_argument("--all-training-per-episode-gb", type=float, default=2.40)
+    parser.add_argument("--full-preview-per-episode-gb", type=float, default=5.10)
+    parser.add_argument("--windows-per-episode", type=int, default=1161)
+    parser.add_argument("--test-fraction", type=float, default=0.20)
+    parser.add_argument("--output", type=Path, default=Path("outputs/omni_exploration/finetune_sample_budget.json"))
+    return parser.parse_args()
+
+
+def measured_free_gb(storage_root: Path, override: float | None) -> float:
+    if override is not None:
+        return float(override)
+    if not storage_root.exists():
+        raise FileNotFoundError(f"storage root does not exist: {storage_root}")
+    return shutil.disk_usage(storage_root).free / GB
+
+
+def max_episodes_for_budget(available_data_gb: float, per_episode_gb: float) -> int:
+    if available_data_gb <= 0 or per_episode_gb <= 0:
+        return 0
+    return max(0, int(math.floor(available_data_gb / per_episode_gb)))
+
+
+def split_windows(episodes: int, windows_per_episode: int, test_fraction: float) -> dict:
+    if episodes <= 0:
+        return {"train_episodes": 0, "test_episodes": 0, "train_windows": 0, "test_windows": 0}
+    test_episodes = max(1, int(round(episodes * test_fraction))) if episodes > 1 else 1
+    train_episodes = max(0, episodes - test_episodes)
+    return {
+        "train_episodes": train_episodes,
+        "test_episodes": test_episodes,
+        "train_windows": train_episodes * windows_per_episode,
+        "test_windows": test_episodes * windows_per_episode,
+    }
+
+
+def phase_rows(max_all_training: int, windows_per_episode: int, test_fraction: float) -> list[dict]:
+    phase_specs = [
+        ("smoke", 1, "Verify loaders, alignment, and heads."),
+        ("smoke_plus", 3, "Catch obvious multi-episode path issues."),
+        ("pilot", 16, "First held-out-episode evaluation."),
+        ("recommended_next", 32, "Default next run if download layout is clean."),
+        ("useful_lora_small", 64, "Train sensor adapters plus selected LoRA layers."),
+        ("useful_lora_medium", 128, "More useful LoRA run after pilot is stable."),
+        ("storage_heavy", 256, "Only after checkpoint size and data layout are stable."),
+    ]
+    rows = []
+    for name, episodes, purpose in phase_specs:
+        split = split_windows(episodes, windows_per_episode, test_fraction)
+        rows.append({
+            "phase": name,
+            "episodes": episodes,
+            "feasible_under_all_training_budget": episodes <= max_all_training,
+            "approx_windows": episodes * windows_per_episode,
+            **split,
+            "purpose": purpose,
+        })
+    return rows
+
+
+def choose_recommendation(max_all_training: int) -> int:
+    for candidate in (32, 16, 8, 3, 1):
+        if max_all_training >= candidate:
+            return candidate
+    return 0
+
+
+def main() -> int:
+    args = parse_args()
+    free_gb = measured_free_gb(args.storage_root.expanduser(), args.free_gb)
+    reserved_gb = args.target_free_after_download_gb + args.model_cache_gb + args.checkpoint_cache_gb + args.log_cache_gb
+    available_data_gb = max(0.0, free_gb - reserved_gb)
+
+    modes = {
+        "minimal_annotation_plus_one_video": args.minimal_per_episode_gb,
+        "all_training_files_no_rrd": args.all_training_per_episode_gb,
+        "full_preview_including_rrd": args.full_preview_per_episode_gb,
+    }
+    mode_summary = {
+        name: {
+            "per_episode_gb": per_episode_gb,
+            "max_episodes": max_episodes_for_budget(available_data_gb, per_episode_gb),
+        }
+        for name, per_episode_gb in modes.items()
+    }
+    max_all_training = mode_summary["all_training_files_no_rrd"]["max_episodes"]
+    recommended = choose_recommendation(max_all_training)
+
+    payload = {
+        "assumptions": {
+            "storage_root": str(args.storage_root),
+            "measured_or_overridden_free_gb": round(free_gb, 3),
+            "target_free_after_download_gb": args.target_free_after_download_gb,
+            "reserved_model_cache_gb": args.model_cache_gb,
+            "reserved_checkpoint_cache_gb": args.checkpoint_cache_gb,
+            "reserved_log_cache_gb": args.log_cache_gb,
+            "available_for_episode_data_gb": round(available_data_gb, 3),
+            "windows_per_episode": args.windows_per_episode,
+            "test_fraction": args.test_fraction,
+            "note": "Episode sizes are estimates until build_episode_manifest.py scans the actual downloaded folders.",
+        },
+        "modes": mode_summary,
+        "recommended_next_episodes": recommended,
+        "recommended_next_reason": (
+            "Use 32 episodes first when feasible; otherwise use the largest smaller phase. "
+            "Scale to 64 or 128 only after the pilot download and held-out-episode evaluation are stable."
+        ),
+        "phases": phase_rows(max_all_training, args.windows_per_episode, args.test_fraction),
+    }
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(json.dumps(payload["assumptions"], indent=2))
+    print(json.dumps({"recommended_next_episodes": recommended, "modes": mode_summary}, indent=2))
+    print(f"Wrote {args.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/omni/qwen3_omni_adapter_smoke.py

@@ -0,0 +1,493 @@
+#!/usr/bin/env python3
+"""Minimum real-data adapter smoke test for an Xperience-10M -> Qwen3-Omni path.
+
+This script does not pretend to fine-tune Qwen3-Omni itself. It validates the
+part that Xperience-10M sensor modalities need before they can be attached
+to an omni backbone: windowing real episodes, turning sensor blocks into
+adapter tokens, and training/evaluating a small task head on real labels.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import sys
+from collections import Counter, OrderedDict
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+
+DIRECT_QWEN3_INPUTS = [
+    "rgb/fisheye video",
+    "embedded mp4 audio",
+    "language annotation prompt",
+]
+
+ADAPTER_INPUTS = [
+    "depth/confidence",
+    "pose/SLAM camera trajectory",
+    "motion capture hand/body joints",
+    "IMU accel/gyro",
+    "contacts/object state features",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    workspace_default = Path(__file__).resolve().parents[2]
+    parser = argparse.ArgumentParser(description="Run a real-data Xperience-10M sensor-adapter smoke test.")
+    parser.add_argument("--workspace", type=Path, default=workspace_default)
+    parser.add_argument(
+        "--episode-root",
+        type=Path,
+        action="append",
+        help="Episode folder containing annotation.hdf5. May be passed multiple times.",
+    )
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        help="Manifest produced by build_episode_manifest.py. Episodes from this file are appended.",
+    )
+    parser.add_argument("--target", choices=["action", "subtask"], default="action")
+    parser.add_argument("--output-dir", type=Path, default=workspace_default / "outputs/omni_exploration/qwen3_adapter_smoke")
+    parser.add_argument("--cache-dir", type=Path, default=workspace_default / "outputs/omni_exploration/feature_cache")
+    parser.add_argument("--base-model-id", default="Qwen/Qwen3-Omni-30B-A3B-Thinking")
+    parser.add_argument("--window-frames", type=int, default=20)
+    parser.add_argument("--stride-frames", type=int, default=20)
+    parser.add_argument("--min-label-fraction", type=float, default=0.6)
+    parser.add_argument("--max-windows-per-episode", type=int, default=128)
+    parser.add_argument("--test-fraction", type=float, default=0.30)
+    parser.add_argument("--epochs", type=int, default=3)
+    parser.add_argument("--batch-size", type=int, default=32)
+    parser.add_argument("--hidden-dim", type=int, default=192)
+    parser.add_argument("--transformer-layers", type=int, default=1)
+    parser.add_argument("--learning-rate", type=float, default=2e-3)
+    parser.add_argument("--weight-decay", type=float, default=1e-3)
+    parser.add_argument("--seed", type=int, default=7)
+    parser.add_argument("--device", default="cuda", choices=["cuda", "cpu", "auto"])
+    parser.add_argument("--force-rebuild-cache", action="store_true")
+    parser.add_argument("--video-image-size", type=int, default=32)
+    parser.add_argument("--video-grid-size", type=int, default=8)
+    parser.add_argument("--video-hist-bins", type=int, default=8)
+    parser.add_argument("--depth-grid-size", type=int, default=8)
+    parser.add_argument("--text-hash-dim", type=int, default=128)
+    parser.add_argument("--include-label-text", action="store_true")
+    parser.add_argument(
+        "--skip-video-features",
+        action="store_true",
+        help="Do not decode MP4s for handcrafted visual features. The direct Qwen3 path is still recorded.",
+    )
+    return parser.parse_args()
+
+
+def add_repo_imports(workspace: Path) -> None:
+    scripts = workspace / "scripts"
+    if str(scripts) not in sys.path:
+        sys.path.insert(0, str(scripts))
+
+
+def add_toolkit_to_path(workspace: Path) -> None:
+    toolkit = workspace / "HOMIE-toolkit"
+    if not toolkit.exists():
+        raise FileNotFoundError(f"HOMIE-toolkit not found: {toolkit}")
+    if str(toolkit) not in sys.path:
+        sys.path.insert(0, str(toolkit))
+
+
+def episode_dirs_from_args(args: argparse.Namespace) -> list[Path]:
+    episode_dirs: list[Path] = []
+    if args.episode_root:
+        episode_dirs.extend(path.expanduser().resolve() for path in args.episode_root)
+    if args.manifest:
+        payload = json.loads(args.manifest.read_text(encoding="utf-8"))
+        for ep in payload.get("episodes", []):
+            path = Path(ep["path"]).expanduser().resolve()
+            if path not in episode_dirs:
+                episode_dirs.append(path)
+    if not episode_dirs:
+        default = args.workspace / "data/sample/xperience-10m-sample"
+        episode_dirs.append(default.resolve())
+    return episode_dirs
+
+
+@dataclass
+class EpisodeDataset:
+    episode_id: str
+    X: np.ndarray
+    labels: np.ndarray
+    starts: np.ndarray
+    ends: np.ndarray
+    feature_manifest: list[dict]
+    available_modalities: list[dict]
+
+
+def load_episode(args: argparse.Namespace, episode_dir: Path) -> EpisodeDataset:
+    from data_loader import load_from_annotation_hdf5
+    from train_all_modalities_model import build_feature_dataset, prepare_modalities, VIDEO_FILES
+
+    annotation = episode_dir / "annotation.hdf5"
+    if not annotation.exists():
+        raise FileNotFoundError(f"Missing annotation.hdf5: {annotation}")
+
+    ann = load_from_annotation_hdf5(annotation, 0, None, load_slam_point_cloud=True)
+    local_args = argparse.Namespace(**vars(args))
+    local_args.annotation = annotation
+    local_args.cache_dir = args.cache_dir / episode_dir.name
+
+    if args.skip_video_features:
+        original_video_files = VIDEO_FILES.copy()
+        VIDEO_FILES.clear()
+        try:
+            extras, available_modalities = prepare_modalities(local_args, ann)
+        finally:
+            VIDEO_FILES.clear()
+            VIDEO_FILES.update(original_video_files)
+    else:
+        extras, available_modalities = prepare_modalities(local_args, ann)
+
+    X, labels, starts, ends, _label_fracs, feature_manifest = build_feature_dataset(
+        ann,
+        extras,
+        target=args.target,
+        window_frames=args.window_frames,
+        stride_frames=args.stride_frames,
+        min_label_fraction=args.min_label_fraction,
+    )
+    if args.max_windows_per_episode > 0 and len(labels) > args.max_windows_per_episode:
+        keep = np.linspace(0, len(labels) - 1, args.max_windows_per_episode, dtype=np.int64)
+        X = X[keep]
+        labels = labels[keep]
+        starts = starts[keep]
+        ends = ends[keep]
+    return EpisodeDataset(
+        episode_id=episode_dir.name,
+        X=X.astype(np.float32),
+        labels=labels,
+        starts=starts,
+        ends=ends,
+        feature_manifest=feature_manifest,
+        available_modalities=available_modalities,
+    )
+
+
+def align_feature_dims(episodes: list[EpisodeDataset]) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, list[dict]]:
+    max_dim = max(ep.X.shape[1] for ep in episodes)
+    Xs, labels, episode_ids, window_ids = [], [], [], []
+    for ep in episodes:
+        X = ep.X
+        if X.shape[1] < max_dim:
+            padded = np.zeros((X.shape[0], max_dim), dtype=np.float32)
+            padded[:, : X.shape[1]] = X
+            X = padded
+        Xs.append(X)
+        labels.extend([str(x) for x in ep.labels])
+        episode_ids.extend([ep.episode_id] * len(ep.labels))
+        window_ids.extend(range(len(ep.labels)))
+    manifest = max(episodes, key=lambda ep: ep.X.shape[1]).feature_manifest
+    return (
+        np.concatenate(Xs, axis=0).astype(np.float32),
+        np.asarray(labels, dtype=object),
+        np.asarray(episode_ids, dtype=object),
+        np.asarray(window_ids, dtype=np.int64),
+        manifest,
+    )
+
+
+def encode_labels(labels: np.ndarray) -> tuple[np.ndarray, list[str]]:
+    seen = OrderedDict()
+    for label in labels:
+        if label not in seen:
+            seen[label] = len(seen)
+    return np.asarray([seen[label] for label in labels], dtype=np.int64), list(seen.keys())
+
+
+def split_indices(episode_ids: np.ndarray, labels: np.ndarray, test_fraction: float, seed: int) -> tuple[np.ndarray, np.ndarray, str]:
+    unique_episodes = np.unique(episode_ids)
+    if len(unique_episodes) >= 2:
+        n_test = max(1, int(round(len(unique_episodes) * test_fraction)))
+        heldout = set(unique_episodes[-n_test:].tolist())
+        test = np.asarray([i for i, ep in enumerate(episode_ids) if ep in heldout], dtype=np.int64)
+        train = np.asarray([i for i, ep in enumerate(episode_ids) if ep not in heldout], dtype=np.int64)
+        return train, test, "held_out_episode"
+
+    # Single-episode smoke: use a chronological split, not shuffled windows.
+    n = len(labels)
+    cut = max(1, min(n - 1, int(round(n * (1.0 - test_fraction)))))
+    return np.arange(cut, dtype=np.int64), np.arange(cut, n, dtype=np.int64), "single_episode_chronological"
+
+
+def block_slices(feature_manifest: list[dict], input_dim: int) -> list[tuple[str, int, int]]:
+    slices = []
+    for block in feature_manifest:
+        start = int(block["start"])
+        end = min(int(block["end"]), input_dim)
+        if start < end:
+            slices.append((str(block["name"]), start, end))
+    if not slices:
+        slices.append(("all_features", 0, input_dim))
+    return slices
+
+
+def macro_f1(y_true: np.ndarray, y_pred: np.ndarray, n_classes: int) -> tuple[float, list[dict], np.ndarray]:
+    cm = np.zeros((n_classes, n_classes), dtype=np.int64)
+    for t, p in zip(y_true, y_pred):
+        cm[int(t), int(p)] += 1
+    rows = []
+    f1s = []
+    for idx in range(n_classes):
+        tp = float(cm[idx, idx])
+        fp = float(cm[:, idx].sum() - cm[idx, idx])
+        fn = float(cm[idx, :].sum() - cm[idx, idx])
+        precision = tp / (tp + fp) if tp + fp else 0.0
+        recall = tp / (tp + fn) if tp + fn else 0.0
+        f1 = 2.0 * precision * recall / (precision + recall) if precision + recall else 0.0
+        f1s.append(f1)
+        rows.append({
+            "class_id": idx,
+            "support": int(cm[idx, :].sum()),
+            "predicted": int(cm[:, idx].sum()),
+            "precision": precision,
+            "recall": recall,
+            "f1": f1,
+        })
+    return float(np.mean(f1s)) if f1s else 0.0, rows, cm
+
+
+def write_csv(path: Path, rows: list[dict], fieldnames: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="", encoding="utf-8") as fp:
+        writer = csv.DictWriter(fp, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def train_adapter_model(
+    X: np.ndarray,
+    y: np.ndarray,
+    train_idx: np.ndarray,
+    test_idx: np.ndarray,
+    blocks: list[tuple[str, int, int]],
+    args: argparse.Namespace,
+) -> tuple[dict, np.ndarray, list[dict]]:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+
+    class SensorAdapterClassifier(nn.Module):
+        def __init__(self, block_specs: list[tuple[str, int, int]], hidden_dim: int, n_classes: int, n_layers: int):
+            super().__init__()
+            self.block_specs = block_specs
+            self.adapters = nn.ModuleList([
+                nn.Sequential(
+                    nn.LayerNorm(end - start),
+                    nn.Linear(end - start, hidden_dim),
+                    nn.GELU(),
+                    nn.Linear(hidden_dim, hidden_dim),
+                )
+                for _name, start, end in block_specs
+            ])
+            self.type_embedding = nn.Parameter(torch.randn(len(block_specs), hidden_dim) * 0.02)
+            layer = nn.TransformerEncoderLayer(
+                d_model=hidden_dim,
+                nhead=max(1, min(8, hidden_dim // 32)),
+                dim_feedforward=hidden_dim * 4,
+                dropout=0.10,
+                batch_first=True,
+                activation="gelu",
+                norm_first=True,
+            )
+            self.fusion = nn.TransformerEncoder(layer, num_layers=n_layers)
+            self.head = nn.Sequential(nn.LayerNorm(hidden_dim), nn.Linear(hidden_dim, n_classes))
+
+        def forward(self, features: torch.Tensor) -> torch.Tensor:
+            tokens = []
+            for adapter, (_name, start, end) in zip(self.adapters, self.block_specs):
+                tokens.append(adapter(features[:, start:end]))
+            x = torch.stack(tokens, dim=1) + self.type_embedding.unsqueeze(0)
+            x = self.fusion(x)
+            pooled = x.mean(dim=1)
+            return self.head(pooled)
+
+    if args.device == "auto":
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    elif args.device == "cuda" and not torch.cuda.is_available():
+        device = torch.device("cpu")
+    else:
+        device = torch.device(args.device)
+
+    torch.manual_seed(args.seed)
+    X_mean = X[train_idx].mean(axis=0, keepdims=True)
+    X_std = X[train_idx].std(axis=0, keepdims=True)
+    X_std[X_std < 1e-6] = 1.0
+    Xs = (X - X_mean) / X_std
+
+    x_tensor = torch.from_numpy(Xs.astype(np.float32))
+    y_tensor = torch.from_numpy(y.astype(np.int64))
+    train_tensor = torch.from_numpy(train_idx.astype(np.int64))
+    test_tensor = torch.from_numpy(test_idx.astype(np.int64))
+
+    n_classes = int(y.max()) + 1
+    model = SensorAdapterClassifier(blocks, args.hidden_dim, n_classes, args.transformer_layers).to(device)
+    counts = np.bincount(y[train_idx], minlength=n_classes).astype(np.float32)
+    weights = counts.sum() / np.maximum(counts, 1.0)
+    weights = weights / weights.mean()
+    class_weights = torch.from_numpy(weights.astype(np.float32)).to(device)
+    opt = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)
+
+    history = []
+    gen = torch.Generator()
+    gen.manual_seed(args.seed)
+    for epoch in range(1, args.epochs + 1):
+        perm = train_tensor[torch.randperm(len(train_tensor), generator=gen)]
+        total_loss = 0.0
+        correct = 0
+        seen = 0
+        model.train()
+        for start in range(0, len(perm), args.batch_size):
+            idx = perm[start : start + args.batch_size]
+            xb = x_tensor[idx].to(device)
+            yb = y_tensor[idx].to(device)
+            logits = model(xb)
+            loss = F.cross_entropy(logits, yb, weight=class_weights)
+            opt.zero_grad(set_to_none=True)
+            loss.backward()
+            opt.step()
+            total_loss += float(loss.detach().cpu()) * len(idx)
+            pred = logits.argmax(dim=1)
+            correct += int((pred == yb).sum().detach().cpu())
+            seen += len(idx)
+        history.append({"epoch": epoch, "loss": total_loss / max(seen, 1), "train_accuracy": correct / max(seen, 1)})
+
+    model.eval()
+    with torch.no_grad():
+        logits = []
+        for start in range(0, len(test_tensor), args.batch_size):
+            idx = test_tensor[start : start + args.batch_size]
+            logits.append(model(x_tensor[idx].to(device)).detach().cpu())
+        test_logits = torch.cat(logits, dim=0)
+        probs = torch.softmax(test_logits, dim=1).numpy()
+        pred = probs.argmax(axis=1).astype(np.int64)
+
+    artifact = {
+        "model_state": model.state_dict(),
+        "feature_mean": X_mean.astype(np.float32),
+        "feature_std": X_std.astype(np.float32),
+        "blocks": blocks,
+        "history": history,
+    }
+    return artifact, pred, history
+
+
+def main() -> int:
+    args = parse_args()
+    args.workspace = args.workspace.expanduser().resolve()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    args.cache_dir.mkdir(parents=True, exist_ok=True)
+    add_repo_imports(args.workspace)
+    add_toolkit_to_path(args.workspace)
+
+    episode_dirs = episode_dirs_from_args(args)
+    episodes = [load_episode(args, path) for path in episode_dirs]
+    X, labels, episode_ids, window_ids, feature_manifest = align_feature_dims(episodes)
+    y, class_names = encode_labels(labels)
+    train_idx, test_idx, split_name = split_indices(episode_ids, labels, args.test_fraction, args.seed)
+    if len(train_idx) == 0 or len(test_idx) == 0:
+        raise ValueError("Need non-empty train and test splits.")
+    blocks = block_slices(feature_manifest, X.shape[1])
+
+    artifact, pred, history = train_adapter_model(X, y, train_idx, test_idx, blocks, args)
+    y_test = y[test_idx]
+    accuracy = float(np.mean(pred == y_test))
+    macro, per_class, cm = macro_f1(y_test, pred, len(class_names))
+    for row in per_class:
+        row["class_name"] = class_names[int(row["class_id"])]
+
+    import torch
+
+    model_path = args.output_dir / "sensor_adapter_model.pt"
+    torch.save(artifact, model_path)
+
+    prediction_rows = []
+    for local_pos, pred_id in enumerate(pred):
+        absolute_idx = int(test_idx[local_pos])
+        true_id = int(y[absolute_idx])
+        prediction_rows.append({
+            "sample_index": absolute_idx,
+            "episode_id": str(episode_ids[absolute_idx]),
+            "window_id": int(window_ids[absolute_idx]),
+            "true_label": class_names[true_id],
+            "predicted_label": class_names[int(pred_id)],
+            "correct": int(true_id == int(pred_id)),
+        })
+
+    metrics = {
+        "task": f"qwen3_omni_sensor_adapter_smoke_{args.target}",
+        "base_model_target": args.base_model_id,
+        "qwen3_loaded": False,
+        "qwen3_note": "This run validates Xperience-10M sensor-adapter tokens and task heads before loading or LoRA-tuning Qwen3-Omni.",
+        "split": split_name,
+        "num_episodes": len(episodes),
+        "num_windows": int(len(labels)),
+        "num_train_windows": int(len(train_idx)),
+        "num_test_windows": int(len(test_idx)),
+        "num_classes": int(len(class_names)),
+        "feature_dim": int(X.shape[1]),
+        "num_adapter_tokens": int(len(blocks)),
+        "accuracy": accuracy,
+        "macro_f1": macro,
+        "train_final_loss": float(history[-1]["loss"]),
+        "train_final_accuracy": float(history[-1]["train_accuracy"]),
+        "direct_qwen3_inputs": DIRECT_QWEN3_INPUTS,
+        "adapter_required_inputs": ADAPTER_INPUTS,
+    }
+
+    (args.output_dir / "metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8")
+    (args.output_dir / "feature_manifest.json").write_text(json.dumps(feature_manifest, indent=2), encoding="utf-8")
+    (args.output_dir / "adapter_blocks.json").write_text(
+        json.dumps([{"name": name, "start": start, "end": end, "dim": end - start} for name, start, end in blocks], indent=2),
+        encoding="utf-8",
+    )
+    (args.output_dir / "available_modalities.json").write_text(
+        json.dumps([{"episode_id": ep.episode_id, "modalities": ep.available_modalities} for ep in episodes], indent=2),
+        encoding="utf-8",
+    )
+    write_csv(args.output_dir / "predictions.csv", prediction_rows, ["sample_index", "episode_id", "window_id", "true_label", "predicted_label", "correct"])
+    write_csv(
+        args.output_dir / "per_class_metrics.csv",
+        per_class,
+        ["class_id", "class_name", "support", "predicted", "precision", "recall", "f1"],
+    )
+    with (args.output_dir / "confusion_matrix.csv").open("w", newline="", encoding="utf-8") as fp:
+        writer = csv.writer(fp)
+        writer.writerow(["true\\pred"] + class_names)
+        for i, name in enumerate(class_names):
+            writer.writerow([name] + [int(x) for x in cm[i]])
+
+    report = [
+        "# Qwen3-Omni Adapter Smoke Test",
+        "",
+        f"- Base model target: `{args.base_model_id}`",
+        "- Qwen3-Omni weights loaded: `false`",
+        f"- Episodes: `{len(episodes)}`",
+        f"- Windows: `{len(labels)}` total, `{len(train_idx)}` train, `{len(test_idx)}` test",
+        f"- Split: `{split_name}`",
+        f"- Feature dimension: `{X.shape[1]}`",
+        f"- Adapter soft-token blocks: `{len(blocks)}`",
+        f"- Accuracy: `{accuracy:.4f}`",
+        f"- Macro-F1: `{macro:.4f}`",
+        "",
+        "## Why this is the minimum real test",
+        "",
+        "This run uses real Ropedia annotation/video-derived feature blocks. It tests the sensor-adapter side that depth, pose, mocap, contacts, and IMU need before those tokens are attached to Qwen3-Omni. It deliberately avoids downloading the 30B Qwen3-Omni weights until the data path, labels, splits, and storage plan are confirmed.",
+    ]
+    (args.output_dir / "RUN_REPORT.md").write_text("\n".join(report) + "\n", encoding="utf-8")
+    print(json.dumps(metrics, indent=2))
+    print(f"Wrote {args.output_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/omni/qwen3_omni_next_steps.md

@@ -0,0 +1,20 @@
+# Qwen3-Omni Exploration Notes
+
+This directory separates the concrete Qwen3-Omni plan into two layers.
+
+1. Native Qwen3-Omni inputs: RGB/fisheye video, embedded audio, and text prompts.
+2. Xperience-10M sensor adapter inputs: depth, pose/SLAM, mocap, contacts, and IMU.
+
+`qwen3_omni_adapter_smoke.py` validates the second layer first using real
+episode windows and real labels. It does not fabricate Qwen outputs and does not
+claim Qwen3-Omni was fine-tuned. Once multiple episodes are available and the
+storage budget is clear, the next step is to attach the saved adapter tokens to
+Qwen3-Omni through LoRA or a cross-attention memory bridge.
+
+Suggested progression:
+
+1. Run the adapter smoke test on one public sample episode.
+2. Add a small manifest of additional episodes, capped by storage.
+3. Hold out whole episodes for evaluation.
+4. Load Qwen3-Omni processor/model on H20 only after data flow is verified.
+5. Train sensor adapters first, then LoRA selected Qwen3-Omni layers.

scripts/render_overview_figures.py

@@ -356,7 +356,7 @@ def build_pipeline_html(summary: dict, base_path: Path) -> str:
       <header>
         <div>
           <div class="kicker">verified single-episode pipeline</div>
-          <h1>From Ropedia episode to reproducible artifacts</h1>
+          <h1>From Xperience-10M episode to reproducible artifacts</h1>
           <p class="subtitle">The figure follows the actual code path and separates the full Xperience-10M sample modalities from the current baseline feature manifest.</p>
         </div>
         <div class="metrics">
@@ -694,7 +694,7 @@ def build_architecture_html(summary: dict, base_path: Path) -> str:
       <header>
         <div>
           <div class="kicker">minimal verified model architectures</div>
-          <h1>12 Ropedia episode tasks, four reusable heads</h1>
+          <h1>12 Xperience-10M episode tasks, four reusable heads</h1>
           <p class="subtitle">Each task uses the same aligned episode-window contract, then swaps only the minimal output head needed for labels, forecasting, grounding, reconstruction, or temporal diagnostics.</p>
         </div>
         <div class="summary-pill"><strong>{len(suite['tasks'])}</strong><span>end-to-end tasks</span></div>

scripts/render_task_suite_infographic.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Render a polished 12-task Ropedia episode-suite infographic.
+Render a polished 12-task Xperience-10M episode-suite infographic.
 
 The task names, inputs, and metrics are read from
 results/episode_task_suite/summary_report.json. The output is a deterministic
@@ -550,7 +550,7 @@ def build_html(summary: dict, base_image: Path | None, sample_dir: Path | None)
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width={CANVAS_WIDTH}, initial-scale=1">
-  <title>Ropedia 12-Task Episode Suite Infographic</title>
+  <title>Xperience-10M 12-Task Episode Suite Infographic</title>
   <style>
     * {{ box-sizing: border-box; }}
     html,
@@ -897,13 +897,13 @@ def build_html(summary: dict, base_image: Path | None, sample_dir: Path | None)
   </style>
 </head>
 <body>
-  <main class="canvas" aria-label="Ropedia 12-task episode suite infographic">
+  <main class="canvas" aria-label="Xperience-10M 12-task episode suite infographic">
     {base_layer}
     <div class="content">
     <header class="header">
       <div>
         <div class="kicker">verified single-episode task suite</div>
-        <h1>Ropedia 12-task episode suite</h1>
+        <h1>Xperience-10M 12-task episode suite</h1>
         <p class="subtitle">A clean map from synchronized multimodal windows to 12 auditable task heads, with metrics loaded from the committed summary report.</p>
       </div>
       <div class="stats">{stats_html}</div>

scripts/train_all_modalities_model.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-All-modality lightweight baseline for a Ropedia/Xperience episode.
+All-modality lightweight baseline for an Xperience-10M episode.
 
 This intentionally stays small enough for a MacBook:
   - no deep video training

scripts/train_min_action_model.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Minimal end-to-end action-recognition pipeline for a Ropedia/Xperience episode.
+Minimal end-to-end action-recognition pipeline for an Xperience-10M episode.
 
 Input:
   annotation.hdf5