Publish Xperience-10M minimal and neural derived artifacts

PROJECT_README.md

@@ -16,6 +16,7 @@ into:
 - 12 end-to-end episode-level tasks,
 - lightweight neural MLP heads for the same 12 task contracts,
 - a generated four-direction research taxonomy matching the Ropedia job tracks,
+- junior-friendly walkthroughs for every task, with case study, input, process, and output,
 - a next TODO track for Qwen3-Omni fine-tuning and sensor-bridge evaluation,
 - metrics, predictions, model weights, manifests, charts, and a static website,
 - a clear explanation of what a single episode can and cannot prove.
@@ -105,6 +106,7 @@ scripts/
   episode_task_suite.py             # 12 end-to-end task definitions
   neural_task_models.py             # optional PyTorch MLP heads for all 12 tasks
   research_direction_taxonomy.py    # maps 12 tasks to the four research tracks
+  task_walkthroughs.py              # beginner explanations for each task contract
   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
@@ -122,12 +124,14 @@ results/
   episode_task_suite/               # 12-task suite metrics and predictions
     neural_mlp/                     # optional neural baseline artifacts per task
     research_directions/            # four-track taxonomy, CSV, and summary
+    task_walkthroughs/              # case-study walkthroughs for all 12 tasks
   omni_exploration/                 # H20/ModelScope smoke-test artifacts
 
 docs/
   index.html                        # GitHub Pages dashboard
   data/summary_metrics.json         # website-readable metrics bundle
   data/research_directions.json     # four-track website data bundle
+  data/task_walkthroughs.json       # beginner task explanation data bundle
   assets/task_suite_infographic.png # 12-task presentation graphic
   assets/pipeline_diagram.png       # verified episode pipeline graphic
   assets/task_architectures.png     # verified 12-task minimal architecture map
@@ -319,6 +323,7 @@ Refresh charts and the website data bundle:
 
 ```bash
 python scripts/research_direction_taxonomy.py
+python scripts/task_walkthroughs.py
 python scripts/generate_visualizations.py
 python scripts/render_overview_figures.py
 python scripts/render_task_suite_infographic.py
@@ -412,6 +417,40 @@ the Xperience-10M sample modalities, but only direction C is strongly represente
 by the current 12-task suite. Directions A, B, and D need additional targets and
 multi-episode training before they become full research deliverables.
 
+## Task Walkthroughs For Juniors
+
+Every task now has a beginner-facing explanation with:
+
+- a concrete coffee-episode case study,
+- exact input contract,
+- middle process modules,
+- output contract,
+- minimal and neural metric,
+- one important limitation.
+
+Primary files:
+
+- [`TASK_WALKTHROUGHS.md`](results/episode_task_suite/task_walkthroughs/TASK_WALKTHROUGHS.md)
+- [`task_walkthroughs.json`](results/episode_task_suite/task_walkthroughs/task_walkthroughs.json)
+- [`docs/data/task_walkthroughs.json`](docs/data/task_walkthroughs.json)
+
+Compact map:
+
+| Task | Case study | Input -> process -> output |
+| --- | --- | --- |
+| `timeline_action` | A pouring window should be named as the current action. | all-modality window -> action label builder + classifier -> action class |
+| `timeline_subtask` | A fine action is grouped into a broader drink-preparation stage. | all-modality window -> subtask label builder + classifier -> subtask label |
+| `transition_detection` | Detect the change from preparing to pouring. | window -> boundary builder + binary classifier -> boundary/steady |
+| `next_action` | A preparing window predicts what happens 20 frames later. | current window -> future-label shift + classifier -> next action |
+| `hand_trajectory_forecast` | A hand moving toward a cup becomes a future 3D hand path. | current window -> future mocap target + regressor -> hand trajectory |
+| `contact_prediction` | Decide whether hand/body contact is happening. | non-contact features -> contact target + binary classifier -> contact label |
+| `object_relevance` | Infer milk, cup, coffee, or related objects during pouring. | non-caption features -> multi-hot object target + sigmoid heads -> object set |
+| `caption_grounding` | Query Pour milk into coffee and retrieve the matching moment. | text-like query + candidates -> projection + cosine ranker -> ranked windows |
+| `cross_modal_retrieval` | Motion/IMU from pouring retrieves matching depth/video. | motion/IMU/camera -> projection + candidate index -> ranked depth/video windows |
+| `modality_reconstruction` | Infer depth/video features from motion, IMU, and camera pose. | source modalities -> scaler + regressor -> target modality vector |
+| `temporal_order` | Tell whether reaching then pouring was reversed. | adjacent window pair -> pair combiner + binary classifier -> correct/reversed |
+| `misalignment_detection` | Catch motion paired with visual/depth features shifted in time. | motion side + visual side -> aligned/shifted pair builder + classifier -> aligned/shifted |
+
 ## Minimal 12-Task Architectures
 
 These are deliberately minimal baselines. They are useful because every

README.md

@@ -49,7 +49,9 @@ This is the reviewable half of the project. You can inspect the task outputs, co
 - `docs/assets/task_suite_infographic.png`: ChatGPT-image-backed infographic with low-resolution public-sample modality thumbnails, including audio waveform context, and verified metric overlays
 - `docs/data/summary_metrics.json`: dashboard-readable summary bundle
 - `docs/data/research_directions.json`: generated four-track taxonomy for the website
+- `docs/data/task_walkthroughs.json`: beginner-oriented input/process/output guide for all 12 tasks
 - `results/episode_task_suite/research_directions/`: JSON, CSV, and Markdown task-to-research-track mapping
+- `results/episode_task_suite/task_walkthroughs/`: case-study walkthroughs for every task contract
 - `scripts/*.py`: reproduction scripts
 - `notes/*.md`: interpretation and reproducibility notes
 
@@ -126,6 +128,14 @@ Primary taxonomy artifact:
 
 `results/episode_task_suite/research_directions/research_direction_taxonomy.json`
 
+## Junior Task Walkthroughs
+
+Each task has a case study, input contract, middle process modules, output
+contract, metric, and current limitation. Start here when onboarding a junior
+researcher or engineer:
+
+`results/episode_task_suite/task_walkthroughs/TASK_WALKTHROUGHS.md`
+
 ## Pending 32-Episode Pilot
 
 | Item | Value |

docs/data/task_walkthroughs.json

@@ -0,0 +1,310 @@
+{
+  "source": "results/episode_task_suite/summary_report.json",
+  "scope": {
+    "episode_count": 1,
+    "num_frames": 5821,
+    "num_windows": 1161,
+    "feature_dim": 8378,
+    "window_frames": 20,
+    "stride_frames": 5,
+    "warning": "These walkthroughs explain task contracts on one public sample episode; they are not cross-episode performance claims."
+  },
+  "shared_pipeline": [
+    "Read annotation.hdf5 and synchronized video-derived features.",
+    "Slice the episode into 20-frame windows with stride 5.",
+    "Build an 8,378-d current feature vector from available modality blocks.",
+    "Construct a task-specific target from labels, future frames, paired windows, or modality splits.",
+    "Train a minimal head and, when enabled, a neural MLP head.",
+    "Write metrics, predictions, and model artifacts for review."
+  ],
+  "tasks": {
+    "timeline_action": {
+      "plain_goal": "Look at one short multimodal window and name what action is happening now.",
+      "case_study": "In the coffee-making sample, if the 20-frame window is during a pouring moment, the task asks the model to output an action such as Pour coffee or Pour milk into coffee.",
+      "input": "One 20-frame window represented by the current 8,378-d feature vector: video/depth summaries, pose, SLAM/camera pose, motion capture, IMU, calibration, and language-derived context.",
+      "middle_modules": [
+        "Window builder slices the episode into short overlapping windows.",
+        "Feature assembler concatenates all current feature blocks.",
+        "Label builder reads the action annotation for the center of the window.",
+        "Classifier head maps the window vector to one action class.",
+        "Evaluator compares predicted action labels against the held-out chronological segment."
+      ],
+      "output": "A single action class for the current window.",
+      "junior_tip": "This is like asking: given this tiny movie clip plus sensor readings, what is the person doing right now?",
+      "failure_mode": "The one-episode chronological split contains future action classes that were not present in training, so low test macro-F1 is expected.",
+      "task": "timeline_action",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.05,
+        "neural_mlp": 0.02631578947368421
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "timeline_subtask": {
+      "plain_goal": "Predict the higher-level task stage for the current window.",
+      "case_study": "A pouring action may belong to a broader subtask such as preparing or pouring a drink. The model predicts that broader stage instead of a fine action.",
+      "input": "The same all-modality 8,378-d window vector used by action recognition.",
+      "middle_modules": [
+        "Window builder creates the current temporal slice.",
+        "Feature assembler keeps all available modality blocks.",
+        "Subtask label builder maps the current timestamp to a subtask annotation.",
+        "Classifier head predicts the subtask class.",
+        "Evaluator reports class-balanced scores so rare subtasks matter."
+      ],
+      "output": "A single subtask label for the current window.",
+      "junior_tip": "Action is the verb; subtask is the chapter of the activity.",
+      "failure_mode": "Single-episode ordering means some later subtasks appear only in test, so this is a pipeline check rather than a general benchmark.",
+      "task": "timeline_subtask",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.04954121121178666,
+        "neural_mlp": 0.017518248175182476
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "transition_detection": {
+      "plain_goal": "Detect whether the current window is near a boundary between actions.",
+      "case_study": "When the demonstrator changes from preparing to pouring, the model should flag a boundary instead of a steady action window.",
+      "input": "One all-modality window vector plus labels derived from action-change timestamps.",
+      "middle_modules": [
+        "Boundary builder scans action labels over time and marks windows near a change.",
+        "Feature assembler supplies all current modality features.",
+        "Binary classifier predicts steady vs boundary.",
+        "Boundary matcher checks whether predicted boundary times are close to true boundary times.",
+        "Evaluator reports macro-F1 and timing error, not just accuracy."
+      ],
+      "output": "A binary label: boundary or steady.",
+      "junior_tip": "This is the model's way of saying: something just changed here.",
+      "failure_mode": "Boundaries are rare, so high accuracy can be misleading if the model predicts steady too often.",
+      "task": "transition_detection",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.6551829268292684,
+        "neural_mlp": 0.6484848484848484
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "next_action": {
+      "plain_goal": "Use the current window to guess the action that will happen shortly after it.",
+      "case_study": "If a window shows the person preparing to pour, the target can be the action 20 frames later, such as the start of pouring.",
+      "input": "The current all-modality window vector at time t.",
+      "middle_modules": [
+        "Window builder picks a current time window.",
+        "Future label builder shifts the action target by 20 frames.",
+        "Feature assembler uses only current information, not future features.",
+        "Classifier head predicts the future action class.",
+        "Evaluator checks whether the future action label is correct."
+      ],
+      "output": "A single action class for t+20 frames.",
+      "junior_tip": "This is short-horizon intention prediction: what will the person do next?",
+      "failure_mode": "The public sample has unseen future classes in the chronological test split, which makes this very hard with one episode.",
+      "task": "next_action",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.05925925925925927,
+        "neural_mlp": 0.023529411764705882
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "hand_trajectory_forecast": {
+      "plain_goal": "Predict where the hands will move over the next few frames.",
+      "case_study": "When the hand is moving toward a cup or bottle, the model predicts the future 3D hand-joint path.",
+      "input": "The current all-modality window vector at time t.",
+      "middle_modules": [
+        "Window builder chooses the current sensor window.",
+        "Target builder extracts future left/right hand 3D joints from motion capture.",
+        "Regression head predicts a continuous trajectory, not a class label.",
+        "Output reshaper interprets the vector as future frames and joints.",
+        "Evaluator computes MPJPE, the average 3D joint-position error."
+      ],
+      "output": "A future trajectory vector for left and right hand joints.",
+      "junior_tip": "Instead of naming an action, this task draws the next hand path in 3D.",
+      "failure_mode": "It is still a window-level forecast, not a full policy or long-horizon motion generator.",
+      "task": "hand_trajectory_forecast",
+      "metric": {
+        "key": "mpjpe",
+        "name": "MPJPE",
+        "direction": "lower",
+        "minimal": 0.8222644925117493,
+        "neural_mlp": 0.11163123697042465
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "contact_prediction": {
+      "plain_goal": "Predict whether the body or hand is in contact with something.",
+      "case_study": "During manipulation, the hand may touch a cup, table, or bottle. The task asks whether any contact is happening.",
+      "input": "Non-contact and non-caption feature blocks, so the answer is not directly leaked from the target labels.",
+      "middle_modules": [
+        "Feature selector removes contact-label and caption-label blocks.",
+        "Target builder converts contact annotations into a binary label.",
+        "Binary classifier predicts contact vs no contact.",
+        "Evaluator reports macro-F1 and accuracy.",
+        "Degeneracy checker records whether only one class appears."
+      ],
+      "output": "A binary contact label.",
+      "junior_tip": "This is a simple physical-interaction probe: is the person touching something now?",
+      "failure_mode": "The current public sample is degenerate for this task because one class dominates, so perfect score does not mean the model learned contact physics.",
+      "task": "contact_prediction",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 1.0,
+        "neural_mlp": 1.0
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "object_relevance": {
+      "plain_goal": "Predict which objects matter in the current window.",
+      "case_study": "If the person is pouring milk into coffee, relevant objects may include milk, cup, coffee, or container-like items.",
+      "input": "Non-caption feature blocks, so the model must infer objects from sensors rather than copying the caption words.",
+      "middle_modules": [
+        "Object vocabulary builder collects object labels from annotations.",
+        "Feature selector removes caption-derived label blocks.",
+        "Multi-label target builder creates a multi-hot object vector.",
+        "Sigmoid heads predict each object's relevance independently.",
+        "Evaluator reports micro-F1 and exact-match quality."
+      ],
+      "output": "A multi-label object set for the current window.",
+      "junior_tip": "A window can involve more than one object, so this is not a one-class classifier.",
+      "failure_mode": "Object labels are sparse and language-derived, so this is currently a weak object-centric probe.",
+      "task": "object_relevance",
+      "metric": {
+        "key": "micro_f1",
+        "name": "micro-F1",
+        "direction": "higher",
+        "minimal": 0.18393030009680542,
+        "neural_mlp": 0.1797583081570997
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "caption_grounding": {
+      "plain_goal": "Given a text-like query from annotation, find the matching time window.",
+      "case_study": "A query like Pour milk into coffee should rank the windows from the actual pouring moment higher than unrelated windows.",
+      "input": "Caption/object/interaction query features and a set of candidate sensor-window features.",
+      "middle_modules": [
+        "Query builder converts annotation words into a compact query representation.",
+        "Candidate builder gathers held-out sensor windows.",
+        "Projection head maps sensor windows into the query space.",
+        "Ranker scores candidates by cosine similarity.",
+        "Evaluator reports MRR and top-k retrieval accuracy."
+      ],
+      "output": "A ranked list of windows, with the correct matching window ideally near rank 1.",
+      "junior_tip": "This is search: type a description, retrieve the matching moment.",
+      "failure_mode": "Bag-of-objects text features are too simple for rich language grounding.",
+      "task": "caption_grounding",
+      "metric": {
+        "key": "mrr",
+        "name": "MRR",
+        "direction": "higher",
+        "minimal": 0.017183946083791223,
+        "neural_mlp": 0.01781111161035397
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "cross_modal_retrieval": {
+      "plain_goal": "Use one group of modalities to retrieve the matching window from another group.",
+      "case_study": "Use motion, IMU, and camera-pose signals from a pouring moment to retrieve the matching depth/video representation for that same moment.",
+      "input": "Query side: motion, IMU, and camera/pose features. Candidate side: depth and video features.",
+      "middle_modules": [
+        "Feature splitter separates query modalities from target modalities.",
+        "Projection head maps the query vector into target-modality space.",
+        "Candidate index stores target vectors from held-out windows.",
+        "Ranker retrieves nearest candidates by cosine similarity.",
+        "Evaluator reports MRR, top-1, top-5, and top-10 accuracy."
+      ],
+      "output": "A ranked list of candidate depth/video windows.",
+      "junior_tip": "This checks whether different sensors agree about the same moment in time.",
+      "failure_mode": "Good retrieval means useful alignment signal, but it is not yet 3D reconstruction or rendering.",
+      "task": "cross_modal_retrieval",
+      "metric": {
+        "key": "mrr",
+        "name": "MRR",
+        "direction": "higher",
+        "minimal": 0.26335984006618296,
+        "neural_mlp": 0.1530070022204131
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "modality_reconstruction": {
+      "plain_goal": "Predict one modality feature block from other modality blocks.",
+      "case_study": "Given motion, IMU, and camera-pose signals while the hand moves, predict the matching depth/video feature vector.",
+      "input": "Motion, IMU, and camera/pose features as input; depth/video features as the regression target.",
+      "middle_modules": [
+        "Feature splitter defines source and target modality blocks.",
+        "Scaler normalizes source and target vectors using train statistics.",
+        "Regression head predicts the target feature vector.",
+        "Inverse scaler returns predictions to target scale.",
+        "Evaluator reports MSE, MAE, and R2."
+      ],
+      "output": "A reconstructed depth/video feature vector.",
+      "junior_tip": "This is feature-level imagination: can the model infer what another sensor would see?",
+      "failure_mode": "This reconstructs compressed features, not raw pixels, depth maps, meshes, NeRFs, or Gaussian splats.",
+      "task": "modality_reconstruction",
+      "metric": {
+        "key": "r2",
+        "name": "R2",
+        "direction": "higher",
+        "minimal": -0.016022846771134747,
+        "neural_mlp": -0.010198171891414143
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "temporal_order": {
+      "plain_goal": "Tell whether two nearby windows are in the correct time order.",
+      "case_study": "If window A shows reaching and window B shows pouring, the model should distinguish A then B from B then A.",
+      "input": "A pair of adjacent window vectors, plus their difference vector.",
+      "middle_modules": [
+        "Pair builder creates correct-order and reversed-order examples.",
+        "Feature combiner concatenates first window, second window, and their difference.",
+        "Binary classifier predicts correct vs reversed.",
+        "Evaluator reports F1, precision, and recall.",
+        "Diagnostic reader interprets whether features encode local time direction."
+      ],
+      "output": "A binary label: correct order or reversed order.",
+      "junior_tip": "This asks whether the representation knows which moment came first.",
+      "failure_mode": "It only tests local ordering, not long-term planning or causality.",
+      "task": "temporal_order",
+      "metric": {
+        "key": "f1",
+        "name": "F1",
+        "direction": "higher",
+        "minimal": 0.5487364620938628,
+        "neural_mlp": 0.8717948717948718
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "misalignment_detection": {
+      "plain_goal": "Detect when modalities that should match are shifted out of sync.",
+      "case_study": "Motion from a pouring moment is paired with video/depth from several windows later. The task asks the model to detect that mismatch.",
+      "input": "A motion-side feature group and a visual/depth-side feature group, either aligned or artificially shifted.",
+      "middle_modules": [
+        "Alignment builder creates positive pairs from the same time window.",
+        "Shift builder creates negative pairs by offsetting one modality group.",
+        "Feature combiner joins both sides into one example.",
+        "Binary classifier predicts aligned vs misaligned.",
+        "Evaluator reports F1 and accuracy."
+      ],
+      "output": "A binary label: aligned or shifted.",
+      "junior_tip": "This is a synchronization alarm for multimodal data.",
+      "failure_mode": "Synthetic shifts are useful diagnostics but do not solve calibration, reconstruction, or mapping by themselves.",
+      "task": "misalignment_detection",
+      "metric": {
+        "key": "f1",
+        "name": "F1",
+        "direction": "higher",
+        "minimal": 0.4865671641791045,
+        "neural_mlp": 0.7335243553008597
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    }
+  }
+}

docs/index.html

@@ -465,6 +465,37 @@
       gap: 14px;
       margin-top: 18px;
     }
+    .walkthrough-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 16px;
+    }
+    .walk-card {
+      border: 1px solid var(--line);
+      border-radius: var(--radius);
+      background: var(--surface);
+      padding: 18px;
+      display: grid;
+      gap: 12px;
+      align-content: start;
+    }
+    .walk-card h3 { margin: 0; font-family: var(--font-mono); font-size: 15px; }
+    .walk-card p { margin: 0; color: var(--muted); font-size: 13px; line-height: 1.55; }
+    .walk-flow {
+      display: grid;
+      grid-template-columns: 0.72fr 1.15fr 0.72fr;
+      gap: 8px;
+      align-items: stretch;
+      font-size: 12px;
+    }
+    .walk-flow span {
+      border: 1px solid #e5dfd5;
+      background: #faf7f1;
+      border-radius: 6px;
+      padding: 9px;
+      min-height: 58px;
+    }
+    .walk-flow strong { display: block; color: var(--ink); font-size: 11px; margin-bottom: 4px; text-transform: uppercase; letter-spacing: 0.04em; }
     .artifact {
       border: 1px solid var(--line);
       border-radius: var(--radius);
@@ -506,14 +537,14 @@
     @media (max-width: 960px) {
       .hero-inner, .two-col { grid-template-columns: 1fr; }
       .hero-inner { min-height: 0; }
-      .hero-stats, .models, .task-grid, .artifact-grid, .chart-grid, .callout-row, .direction-grid, .baseline-strip { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+      .hero-stats, .models, .task-grid, .artifact-grid, .chart-grid, .callout-row, .direction-grid, .baseline-strip, .walkthrough-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
       .section-head { display: block; }
       .section-head p { margin-top: 14px; }
       .nav-links { display: none; }
     }
     @media (max-width: 640px) {
       .wrap { width: min(100% - 28px, var(--max)); }
-      .hero-stats, .models, .task-grid, .artifact-grid, .chart-grid, .callout-row, .direction-grid, .baseline-strip { grid-template-columns: 1fr; }
+      .hero-stats, .models, .task-grid, .artifact-grid, .chart-grid, .callout-row, .direction-grid, .baseline-strip, .walkthrough-grid, .walk-flow { grid-template-columns: 1fr; }
       .hero-inner, section { padding: 46px 0; }
       .signal { grid-template-columns: 1fr; }
       .signal strong { text-align: left; }
@@ -544,6 +575,7 @@
         <a href="#neural">Neural</a>
         <a href="#directions">Directions</a>
         <a href="#architectures">Arch</a>
+        <a href="#walkthroughs">Guide</a>
         <a href="#tasks">Tasks</a>
         <a href="#features">Signals</a>
         <a href="#artifacts">Artifacts</a>
@@ -714,6 +746,29 @@
       </div>
     </section>
 
+    <section id="walkthroughs">
+      <div class="wrap">
+        <div class="section-head">
+          <h2>Junior-friendly task walkthroughs.</h2>
+          <p>Each task is explained as a case study with input, middle process modules, and output. The full generated guide is committed as Markdown and JSON.</p>
+        </div>
+        <div class="walkthrough-grid">
+          <article class="walk-card"><h3>timeline_action</h3><p><strong>Case:</strong> a pouring window should map to the current action, such as Pour coffee.</p><div class="walk-flow"><span><strong>Input</strong>one 20-frame all-modality window</span><span><strong>Process</strong>window builder, feature assembler, action label builder, classifier, evaluator</span><span><strong>Output</strong>current action class</span></div></article>
+          <article class="walk-card"><h3>timeline_subtask</h3><p><strong>Case:</strong> a fine action is grouped into a broader drink-preparation stage.</p><div class="walk-flow"><span><strong>Input</strong>one all-modality window</span><span><strong>Process</strong>window builder, feature assembler, subtask label builder, classifier, evaluator</span><span><strong>Output</strong>current subtask label</span></div></article>
+          <article class="walk-card"><h3>transition_detection</h3><p><strong>Case:</strong> detect the moment the demonstrator changes from preparing to pouring.</p><div class="walk-flow"><span><strong>Input</strong>one window plus boundary labels</span><span><strong>Process</strong>boundary builder, feature assembler, binary classifier, boundary matcher, evaluator</span><span><strong>Output</strong>boundary or steady</span></div></article>
+          <article class="walk-card"><h3>next_action</h3><p><strong>Case:</strong> a preparing-to-pour window should predict the action 20 frames later.</p><div class="walk-flow"><span><strong>Input</strong>current window at time t</span><span><strong>Process</strong>future label shift, current-only features, classifier, evaluator</span><span><strong>Output</strong>action at t+20 frames</span></div></article>
+          <article class="walk-card"><h3>hand_trajectory_forecast</h3><p><strong>Case:</strong> when a hand moves toward a cup, predict the future 3D hand path.</p><div class="walk-flow"><span><strong>Input</strong>current all-modality window</span><span><strong>Process</strong>future mocap target builder, regression head, trajectory reshaper, MPJPE evaluator</span><span><strong>Output</strong>future left/right hand joints</span></div></article>
+          <article class="walk-card"><h3>contact_prediction</h3><p><strong>Case:</strong> decide whether the hand/body is touching an object or surface.</p><div class="walk-flow"><span><strong>Input</strong>non-contact, non-caption features</span><span><strong>Process</strong>feature selector, contact target builder, binary classifier, degeneracy check</span><span><strong>Output</strong>contact or no contact</span></div></article>
+          <article class="walk-card"><h3>object_relevance</h3><p><strong>Case:</strong> during pouring, infer relevant objects such as milk, cup, or coffee.</p><div class="walk-flow"><span><strong>Input</strong>non-caption features</span><span><strong>Process</strong>object vocabulary, multi-hot targets, sigmoid heads, micro-F1 evaluator</span><span><strong>Output</strong>multi-label object set</span></div></article>
+          <article class="walk-card"><h3>caption_grounding</h3><p><strong>Case:</strong> a query like Pour milk into coffee should retrieve the matching moment.</p><div class="walk-flow"><span><strong>Input</strong>caption query plus candidate windows</span><span><strong>Process</strong>query builder, candidate builder, projection head, cosine ranker, MRR evaluator</span><span><strong>Output</strong>ranked matching windows</span></div></article>
+          <article class="walk-card"><h3>cross_modal_retrieval</h3><p><strong>Case:</strong> motion and IMU from pouring should retrieve the matching depth/video window.</p><div class="walk-flow"><span><strong>Input</strong>motion/IMU/camera query, depth/video candidates</span><span><strong>Process</strong>modality splitter, projection head, candidate index, cosine ranker, top-k evaluator</span><span><strong>Output</strong>ranked depth/video windows</span></div></article>
+          <article class="walk-card"><h3>modality_reconstruction</h3><p><strong>Case:</strong> infer compressed depth/video features from motion, IMU, and camera pose.</p><div class="walk-flow"><span><strong>Input</strong>motion/IMU/camera features</span><span><strong>Process</strong>source-target split, scaling, regression head, inverse scaling, R2 evaluator</span><span><strong>Output</strong>depth/video feature vector</span></div></article>
+          <article class="walk-card"><h3>temporal_order</h3><p><strong>Case:</strong> tell whether reaching then pouring has been reversed.</p><div class="walk-flow"><span><strong>Input</strong>two adjacent windows</span><span><strong>Process</strong>pair builder, feature combiner, binary classifier, F1 evaluator</span><span><strong>Output</strong>correct or reversed order</span></div></article>
+          <article class="walk-card"><h3>misalignment_detection</h3><p><strong>Case:</strong> detect motion from pouring paired with video/depth shifted later.</p><div class="walk-flow"><span><strong>Input</strong>motion side plus visual/depth side</span><span><strong>Process</strong>aligned pair builder, shifted pair builder, feature combiner, binary classifier</span><span><strong>Output</strong>aligned or shifted</span></div></article>
+        </div>
+      </div>
+    </section>
+
     <section id="tasks">
       <div class="wrap">
         <div class="section-head">
@@ -779,6 +834,7 @@
           <article class="artifact"><h3>Task-suite report</h3><p>One JSON file with every task metric and split detail.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/episode_task_suite/summary_report.json">summary_report.json</a></article>
           <article class="artifact"><h3>Neural MLP task results</h3><p>Per-task PyTorch MLP metrics, predictions, histories, and checkpoints for the same 12 task contracts.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/tree/main/results/episode_task_suite/neural_mlp">neural_mlp/</a></article>
           <article class="artifact"><h3>Four-direction taxonomy</h3><p>Generated JSON, CSV, Markdown, and website data mapping all 12 tasks to the four research tracks with two baselines.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/tree/main/results/episode_task_suite/research_directions">research_directions/</a></article>
+          <article class="artifact"><h3>Task walkthroughs</h3><p>Beginner-oriented case studies for all 12 tasks, including input, middle process modules, output, metric, and limitation.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/tree/main/results/episode_task_suite/task_walkthroughs">task_walkthroughs/</a></article>
           <article class="artifact"><h3>Feature manifest</h3><p>Start/end index and dimension for every current feature block.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/episode_task_suite/feature_manifest.json">feature_manifest.json</a></article>
           <article class="artifact"><h3>Cross-modal retrieval</h3><p>The strongest self-supervised signal from the single episode.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/episode_task_suite/cross_modal_retrieval/metrics.json">metrics.json</a></article>
           <article class="artifact"><h3>Current all-feature action model</h3><p>Classifier metrics, predictions, confusion matrix, and model weights.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/min_all_modalities_action_model/metrics.json">metrics.json</a></article>

results/episode_task_suite/task_walkthroughs/TASK_WALKTHROUGHS.md

@@ -0,0 +1,291 @@
+# Junior-Friendly 12-Task Walkthroughs
+
+This file explains every task in the Xperience-10M episode suite as an input -> process -> output pipeline.
+It is generated by `scripts/task_walkthroughs.py` from committed metrics plus hand-audited task explanations.
+
+## Shared Pipeline
+
+- Read annotation.hdf5 and synchronized video-derived features.
+- Slice the episode into 20-frame windows with stride 5.
+- Build an 8,378-d current feature vector from available modality blocks.
+- Construct a task-specific target from labels, future frames, paired windows, or modality splits.
+- Train a minimal head and, when enabled, a neural MLP head.
+- Write metrics, predictions, and model artifacts for review.
+
+## Task Walkthroughs
+
+### `timeline_action`
+
+**Goal:** Look at one short multimodal window and name what action is happening now.
+
+**Case study:** In the coffee-making sample, if the 20-frame window is during a pouring moment, the task asks the model to output an action such as Pour coffee or Pour milk into coffee.
+
+**Input:** One 20-frame window represented by the current 8,378-d feature vector: video/depth summaries, pose, SLAM/camera pose, motion capture, IMU, calibration, and language-derived context.
+
+**Middle process modules:**
+- Window builder slices the episode into short overlapping windows.
+- Feature assembler concatenates all current feature blocks.
+- Label builder reads the action annotation for the center of the window.
+- Classifier head maps the window vector to one action class.
+- Evaluator compares predicted action labels against the held-out chronological segment.
+
+**Output:** A single action class for the current window.
+
+**Metric:** macro-F1 (higher is better). Minimal `0.0500`, neural MLP `0.0263`.
+
+**Junior mental model:** This is like asking: given this tiny movie clip plus sensor readings, what is the person doing right now?
+
+**Current limitation:** The one-episode chronological split contains future action classes that were not present in training, so low test macro-F1 is expected.
+
+### `timeline_subtask`
+
+**Goal:** Predict the higher-level task stage for the current window.
+
+**Case study:** A pouring action may belong to a broader subtask such as preparing or pouring a drink. The model predicts that broader stage instead of a fine action.
+
+**Input:** The same all-modality 8,378-d window vector used by action recognition.
+
+**Middle process modules:**
+- Window builder creates the current temporal slice.
+- Feature assembler keeps all available modality blocks.
+- Subtask label builder maps the current timestamp to a subtask annotation.
+- Classifier head predicts the subtask class.
+- Evaluator reports class-balanced scores so rare subtasks matter.
+
+**Output:** A single subtask label for the current window.
+
+**Metric:** macro-F1 (higher is better). Minimal `0.0495`, neural MLP `0.0175`.
+
+**Junior mental model:** Action is the verb; subtask is the chapter of the activity.
+
+**Current limitation:** Single-episode ordering means some later subtasks appear only in test, so this is a pipeline check rather than a general benchmark.
+
+### `transition_detection`
+
+**Goal:** Detect whether the current window is near a boundary between actions.
+
+**Case study:** When the demonstrator changes from preparing to pouring, the model should flag a boundary instead of a steady action window.
+
+**Input:** One all-modality window vector plus labels derived from action-change timestamps.
+
+**Middle process modules:**
+- Boundary builder scans action labels over time and marks windows near a change.
+- Feature assembler supplies all current modality features.
+- Binary classifier predicts steady vs boundary.
+- Boundary matcher checks whether predicted boundary times are close to true boundary times.
+- Evaluator reports macro-F1 and timing error, not just accuracy.
+
+**Output:** A binary label: boundary or steady.
+
+**Metric:** macro-F1 (higher is better). Minimal `0.6552`, neural MLP `0.6485`.
+
+**Junior mental model:** This is the model's way of saying: something just changed here.
+
+**Current limitation:** Boundaries are rare, so high accuracy can be misleading if the model predicts steady too often.
+
+### `next_action`
+
+**Goal:** Use the current window to guess the action that will happen shortly after it.
+
+**Case study:** If a window shows the person preparing to pour, the target can be the action 20 frames later, such as the start of pouring.
+
+**Input:** The current all-modality window vector at time t.
+
+**Middle process modules:**
+- Window builder picks a current time window.
+- Future label builder shifts the action target by 20 frames.
+- Feature assembler uses only current information, not future features.
+- Classifier head predicts the future action class.
+- Evaluator checks whether the future action label is correct.
+
+**Output:** A single action class for t+20 frames.
+
+**Metric:** macro-F1 (higher is better). Minimal `0.0593`, neural MLP `0.0235`.
+
+**Junior mental model:** This is short-horizon intention prediction: what will the person do next?
+
+**Current limitation:** The public sample has unseen future classes in the chronological test split, which makes this very hard with one episode.
+
+### `hand_trajectory_forecast`
+
+**Goal:** Predict where the hands will move over the next few frames.
+
+**Case study:** When the hand is moving toward a cup or bottle, the model predicts the future 3D hand-joint path.
+
+**Input:** The current all-modality window vector at time t.
+
+**Middle process modules:**
+- Window builder chooses the current sensor window.
+- Target builder extracts future left/right hand 3D joints from motion capture.
+- Regression head predicts a continuous trajectory, not a class label.
+- Output reshaper interprets the vector as future frames and joints.
+- Evaluator computes MPJPE, the average 3D joint-position error.
+
+**Output:** A future trajectory vector for left and right hand joints.
+
+**Metric:** MPJPE (lower is better). Minimal `0.8223`, neural MLP `0.1116`.
+
+**Junior mental model:** Instead of naming an action, this task draws the next hand path in 3D.
+
+**Current limitation:** It is still a window-level forecast, not a full policy or long-horizon motion generator.
+
+### `contact_prediction`
+
+**Goal:** Predict whether the body or hand is in contact with something.
+
+**Case study:** During manipulation, the hand may touch a cup, table, or bottle. The task asks whether any contact is happening.
+
+**Input:** Non-contact and non-caption feature blocks, so the answer is not directly leaked from the target labels.
+
+**Middle process modules:**
+- Feature selector removes contact-label and caption-label blocks.
+- Target builder converts contact annotations into a binary label.
+- Binary classifier predicts contact vs no contact.
+- Evaluator reports macro-F1 and accuracy.
+- Degeneracy checker records whether only one class appears.
+
+**Output:** A binary contact label.
+
+**Metric:** macro-F1 (higher is better). Minimal `1.0000`, neural MLP `1.0000`.
+
+**Junior mental model:** This is a simple physical-interaction probe: is the person touching something now?
+
+**Current limitation:** The current public sample is degenerate for this task because one class dominates, so perfect score does not mean the model learned contact physics.
+
+### `object_relevance`
+
+**Goal:** Predict which objects matter in the current window.
+
+**Case study:** If the person is pouring milk into coffee, relevant objects may include milk, cup, coffee, or container-like items.
+
+**Input:** Non-caption feature blocks, so the model must infer objects from sensors rather than copying the caption words.
+
+**Middle process modules:**
+- Object vocabulary builder collects object labels from annotations.
+- Feature selector removes caption-derived label blocks.
+- Multi-label target builder creates a multi-hot object vector.
+- Sigmoid heads predict each object's relevance independently.
+- Evaluator reports micro-F1 and exact-match quality.
+
+**Output:** A multi-label object set for the current window.
+
+**Metric:** micro-F1 (higher is better). Minimal `0.1839`, neural MLP `0.1798`.
+
+**Junior mental model:** A window can involve more than one object, so this is not a one-class classifier.
+
+**Current limitation:** Object labels are sparse and language-derived, so this is currently a weak object-centric probe.
+
+### `caption_grounding`
+
+**Goal:** Given a text-like query from annotation, find the matching time window.
+
+**Case study:** A query like Pour milk into coffee should rank the windows from the actual pouring moment higher than unrelated windows.
+
+**Input:** Caption/object/interaction query features and a set of candidate sensor-window features.
+
+**Middle process modules:**
+- Query builder converts annotation words into a compact query representation.
+- Candidate builder gathers held-out sensor windows.
+- Projection head maps sensor windows into the query space.
+- Ranker scores candidates by cosine similarity.
+- Evaluator reports MRR and top-k retrieval accuracy.
+
+**Output:** A ranked list of windows, with the correct matching window ideally near rank 1.
+
+**Metric:** MRR (higher is better). Minimal `0.0172`, neural MLP `0.0178`.
+
+**Junior mental model:** This is search: type a description, retrieve the matching moment.
+
+**Current limitation:** Bag-of-objects text features are too simple for rich language grounding.
+
+### `cross_modal_retrieval`
+
+**Goal:** Use one group of modalities to retrieve the matching window from another group.
+
+**Case study:** Use motion, IMU, and camera-pose signals from a pouring moment to retrieve the matching depth/video representation for that same moment.
+
+**Input:** Query side: motion, IMU, and camera/pose features. Candidate side: depth and video features.
+
+**Middle process modules:**
+- Feature splitter separates query modalities from target modalities.
+- Projection head maps the query vector into target-modality space.
+- Candidate index stores target vectors from held-out windows.
+- Ranker retrieves nearest candidates by cosine similarity.
+- Evaluator reports MRR, top-1, top-5, and top-10 accuracy.
+
+**Output:** A ranked list of candidate depth/video windows.
+
+**Metric:** MRR (higher is better). Minimal `0.2634`, neural MLP `0.1530`.
+
+**Junior mental model:** This checks whether different sensors agree about the same moment in time.
+
+**Current limitation:** Good retrieval means useful alignment signal, but it is not yet 3D reconstruction or rendering.
+
+### `modality_reconstruction`
+
+**Goal:** Predict one modality feature block from other modality blocks.
+
+**Case study:** Given motion, IMU, and camera-pose signals while the hand moves, predict the matching depth/video feature vector.
+
+**Input:** Motion, IMU, and camera/pose features as input; depth/video features as the regression target.
+
+**Middle process modules:**
+- Feature splitter defines source and target modality blocks.
+- Scaler normalizes source and target vectors using train statistics.
+- Regression head predicts the target feature vector.
+- Inverse scaler returns predictions to target scale.
+- Evaluator reports MSE, MAE, and R2.
+
+**Output:** A reconstructed depth/video feature vector.
+
+**Metric:** R2 (higher is better). Minimal `-0.0160`, neural MLP `-0.0102`.
+
+**Junior mental model:** This is feature-level imagination: can the model infer what another sensor would see?
+
+**Current limitation:** This reconstructs compressed features, not raw pixels, depth maps, meshes, NeRFs, or Gaussian splats.
+
+### `temporal_order`
+
+**Goal:** Tell whether two nearby windows are in the correct time order.
+
+**Case study:** If window A shows reaching and window B shows pouring, the model should distinguish A then B from B then A.
+
+**Input:** A pair of adjacent window vectors, plus their difference vector.
+
+**Middle process modules:**
+- Pair builder creates correct-order and reversed-order examples.
+- Feature combiner concatenates first window, second window, and their difference.
+- Binary classifier predicts correct vs reversed.
+- Evaluator reports F1, precision, and recall.
+- Diagnostic reader interprets whether features encode local time direction.
+
+**Output:** A binary label: correct order or reversed order.
+
+**Metric:** F1 (higher is better). Minimal `0.5487`, neural MLP `0.8718`.
+
+**Junior mental model:** This asks whether the representation knows which moment came first.
+
+**Current limitation:** It only tests local ordering, not long-term planning or causality.
+
+### `misalignment_detection`
+
+**Goal:** Detect when modalities that should match are shifted out of sync.
+
+**Case study:** Motion from a pouring moment is paired with video/depth from several windows later. The task asks the model to detect that mismatch.
+
+**Input:** A motion-side feature group and a visual/depth-side feature group, either aligned or artificially shifted.
+
+**Middle process modules:**
+- Alignment builder creates positive pairs from the same time window.
+- Shift builder creates negative pairs by offsetting one modality group.
+- Feature combiner joins both sides into one example.
+- Binary classifier predicts aligned vs misaligned.
+- Evaluator reports F1 and accuracy.
+
+**Output:** A binary label: aligned or shifted.
+
+**Metric:** F1 (higher is better). Minimal `0.4866`, neural MLP `0.7335`.
+
+**Junior mental model:** This is a synchronization alarm for multimodal data.
+
+**Current limitation:** Synthetic shifts are useful diagnostics but do not solve calibration, reconstruction, or mapping by themselves.

results/episode_task_suite/task_walkthroughs/task_walkthroughs.json

@@ -0,0 +1,310 @@
+{
+  "source": "results/episode_task_suite/summary_report.json",
+  "scope": {
+    "episode_count": 1,
+    "num_frames": 5821,
+    "num_windows": 1161,
+    "feature_dim": 8378,
+    "window_frames": 20,
+    "stride_frames": 5,
+    "warning": "These walkthroughs explain task contracts on one public sample episode; they are not cross-episode performance claims."
+  },
+  "shared_pipeline": [
+    "Read annotation.hdf5 and synchronized video-derived features.",
+    "Slice the episode into 20-frame windows with stride 5.",
+    "Build an 8,378-d current feature vector from available modality blocks.",
+    "Construct a task-specific target from labels, future frames, paired windows, or modality splits.",
+    "Train a minimal head and, when enabled, a neural MLP head.",
+    "Write metrics, predictions, and model artifacts for review."
+  ],
+  "tasks": {
+    "timeline_action": {
+      "plain_goal": "Look at one short multimodal window and name what action is happening now.",
+      "case_study": "In the coffee-making sample, if the 20-frame window is during a pouring moment, the task asks the model to output an action such as Pour coffee or Pour milk into coffee.",
+      "input": "One 20-frame window represented by the current 8,378-d feature vector: video/depth summaries, pose, SLAM/camera pose, motion capture, IMU, calibration, and language-derived context.",
+      "middle_modules": [
+        "Window builder slices the episode into short overlapping windows.",
+        "Feature assembler concatenates all current feature blocks.",
+        "Label builder reads the action annotation for the center of the window.",
+        "Classifier head maps the window vector to one action class.",
+        "Evaluator compares predicted action labels against the held-out chronological segment."
+      ],
+      "output": "A single action class for the current window.",
+      "junior_tip": "This is like asking: given this tiny movie clip plus sensor readings, what is the person doing right now?",
+      "failure_mode": "The one-episode chronological split contains future action classes that were not present in training, so low test macro-F1 is expected.",
+      "task": "timeline_action",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.05,
+        "neural_mlp": 0.02631578947368421
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "timeline_subtask": {
+      "plain_goal": "Predict the higher-level task stage for the current window.",
+      "case_study": "A pouring action may belong to a broader subtask such as preparing or pouring a drink. The model predicts that broader stage instead of a fine action.",
+      "input": "The same all-modality 8,378-d window vector used by action recognition.",
+      "middle_modules": [
+        "Window builder creates the current temporal slice.",
+        "Feature assembler keeps all available modality blocks.",
+        "Subtask label builder maps the current timestamp to a subtask annotation.",
+        "Classifier head predicts the subtask class.",
+        "Evaluator reports class-balanced scores so rare subtasks matter."
+      ],
+      "output": "A single subtask label for the current window.",
+      "junior_tip": "Action is the verb; subtask is the chapter of the activity.",
+      "failure_mode": "Single-episode ordering means some later subtasks appear only in test, so this is a pipeline check rather than a general benchmark.",
+      "task": "timeline_subtask",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.04954121121178666,
+        "neural_mlp": 0.017518248175182476
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "transition_detection": {
+      "plain_goal": "Detect whether the current window is near a boundary between actions.",
+      "case_study": "When the demonstrator changes from preparing to pouring, the model should flag a boundary instead of a steady action window.",
+      "input": "One all-modality window vector plus labels derived from action-change timestamps.",
+      "middle_modules": [
+        "Boundary builder scans action labels over time and marks windows near a change.",
+        "Feature assembler supplies all current modality features.",
+        "Binary classifier predicts steady vs boundary.",
+        "Boundary matcher checks whether predicted boundary times are close to true boundary times.",
+        "Evaluator reports macro-F1 and timing error, not just accuracy."
+      ],
+      "output": "A binary label: boundary or steady.",
+      "junior_tip": "This is the model's way of saying: something just changed here.",
+      "failure_mode": "Boundaries are rare, so high accuracy can be misleading if the model predicts steady too often.",
+      "task": "transition_detection",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.6551829268292684,
+        "neural_mlp": 0.6484848484848484
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "next_action": {
+      "plain_goal": "Use the current window to guess the action that will happen shortly after it.",
+      "case_study": "If a window shows the person preparing to pour, the target can be the action 20 frames later, such as the start of pouring.",
+      "input": "The current all-modality window vector at time t.",
+      "middle_modules": [
+        "Window builder picks a current time window.",
+        "Future label builder shifts the action target by 20 frames.",
+        "Feature assembler uses only current information, not future features.",
+        "Classifier head predicts the future action class.",
+        "Evaluator checks whether the future action label is correct."
+      ],
+      "output": "A single action class for t+20 frames.",
+      "junior_tip": "This is short-horizon intention prediction: what will the person do next?",
+      "failure_mode": "The public sample has unseen future classes in the chronological test split, which makes this very hard with one episode.",
+      "task": "next_action",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 0.05925925925925927,
+        "neural_mlp": 0.023529411764705882
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "hand_trajectory_forecast": {
+      "plain_goal": "Predict where the hands will move over the next few frames.",
+      "case_study": "When the hand is moving toward a cup or bottle, the model predicts the future 3D hand-joint path.",
+      "input": "The current all-modality window vector at time t.",
+      "middle_modules": [
+        "Window builder chooses the current sensor window.",
+        "Target builder extracts future left/right hand 3D joints from motion capture.",
+        "Regression head predicts a continuous trajectory, not a class label.",
+        "Output reshaper interprets the vector as future frames and joints.",
+        "Evaluator computes MPJPE, the average 3D joint-position error."
+      ],
+      "output": "A future trajectory vector for left and right hand joints.",
+      "junior_tip": "Instead of naming an action, this task draws the next hand path in 3D.",
+      "failure_mode": "It is still a window-level forecast, not a full policy or long-horizon motion generator.",
+      "task": "hand_trajectory_forecast",
+      "metric": {
+        "key": "mpjpe",
+        "name": "MPJPE",
+        "direction": "lower",
+        "minimal": 0.8222644925117493,
+        "neural_mlp": 0.11163123697042465
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "contact_prediction": {
+      "plain_goal": "Predict whether the body or hand is in contact with something.",
+      "case_study": "During manipulation, the hand may touch a cup, table, or bottle. The task asks whether any contact is happening.",
+      "input": "Non-contact and non-caption feature blocks, so the answer is not directly leaked from the target labels.",
+      "middle_modules": [
+        "Feature selector removes contact-label and caption-label blocks.",
+        "Target builder converts contact annotations into a binary label.",
+        "Binary classifier predicts contact vs no contact.",
+        "Evaluator reports macro-F1 and accuracy.",
+        "Degeneracy checker records whether only one class appears."
+      ],
+      "output": "A binary contact label.",
+      "junior_tip": "This is a simple physical-interaction probe: is the person touching something now?",
+      "failure_mode": "The current public sample is degenerate for this task because one class dominates, so perfect score does not mean the model learned contact physics.",
+      "task": "contact_prediction",
+      "metric": {
+        "key": "macro_f1",
+        "name": "macro-F1",
+        "direction": "higher",
+        "minimal": 1.0,
+        "neural_mlp": 1.0
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "object_relevance": {
+      "plain_goal": "Predict which objects matter in the current window.",
+      "case_study": "If the person is pouring milk into coffee, relevant objects may include milk, cup, coffee, or container-like items.",
+      "input": "Non-caption feature blocks, so the model must infer objects from sensors rather than copying the caption words.",
+      "middle_modules": [
+        "Object vocabulary builder collects object labels from annotations.",
+        "Feature selector removes caption-derived label blocks.",
+        "Multi-label target builder creates a multi-hot object vector.",
+        "Sigmoid heads predict each object's relevance independently.",
+        "Evaluator reports micro-F1 and exact-match quality."
+      ],
+      "output": "A multi-label object set for the current window.",
+      "junior_tip": "A window can involve more than one object, so this is not a one-class classifier.",
+      "failure_mode": "Object labels are sparse and language-derived, so this is currently a weak object-centric probe.",
+      "task": "object_relevance",
+      "metric": {
+        "key": "micro_f1",
+        "name": "micro-F1",
+        "direction": "higher",
+        "minimal": 0.18393030009680542,
+        "neural_mlp": 0.1797583081570997
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "caption_grounding": {
+      "plain_goal": "Given a text-like query from annotation, find the matching time window.",
+      "case_study": "A query like Pour milk into coffee should rank the windows from the actual pouring moment higher than unrelated windows.",
+      "input": "Caption/object/interaction query features and a set of candidate sensor-window features.",
+      "middle_modules": [
+        "Query builder converts annotation words into a compact query representation.",
+        "Candidate builder gathers held-out sensor windows.",
+        "Projection head maps sensor windows into the query space.",
+        "Ranker scores candidates by cosine similarity.",
+        "Evaluator reports MRR and top-k retrieval accuracy."
+      ],
+      "output": "A ranked list of windows, with the correct matching window ideally near rank 1.",
+      "junior_tip": "This is search: type a description, retrieve the matching moment.",
+      "failure_mode": "Bag-of-objects text features are too simple for rich language grounding.",
+      "task": "caption_grounding",
+      "metric": {
+        "key": "mrr",
+        "name": "MRR",
+        "direction": "higher",
+        "minimal": 0.017183946083791223,
+        "neural_mlp": 0.01781111161035397
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "cross_modal_retrieval": {
+      "plain_goal": "Use one group of modalities to retrieve the matching window from another group.",
+      "case_study": "Use motion, IMU, and camera-pose signals from a pouring moment to retrieve the matching depth/video representation for that same moment.",
+      "input": "Query side: motion, IMU, and camera/pose features. Candidate side: depth and video features.",
+      "middle_modules": [
+        "Feature splitter separates query modalities from target modalities.",
+        "Projection head maps the query vector into target-modality space.",
+        "Candidate index stores target vectors from held-out windows.",
+        "Ranker retrieves nearest candidates by cosine similarity.",
+        "Evaluator reports MRR, top-1, top-5, and top-10 accuracy."
+      ],
+      "output": "A ranked list of candidate depth/video windows.",
+      "junior_tip": "This checks whether different sensors agree about the same moment in time.",
+      "failure_mode": "Good retrieval means useful alignment signal, but it is not yet 3D reconstruction or rendering.",
+      "task": "cross_modal_retrieval",
+      "metric": {
+        "key": "mrr",
+        "name": "MRR",
+        "direction": "higher",
+        "minimal": 0.26335984006618296,
+        "neural_mlp": 0.1530070022204131
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "modality_reconstruction": {
+      "plain_goal": "Predict one modality feature block from other modality blocks.",
+      "case_study": "Given motion, IMU, and camera-pose signals while the hand moves, predict the matching depth/video feature vector.",
+      "input": "Motion, IMU, and camera/pose features as input; depth/video features as the regression target.",
+      "middle_modules": [
+        "Feature splitter defines source and target modality blocks.",
+        "Scaler normalizes source and target vectors using train statistics.",
+        "Regression head predicts the target feature vector.",
+        "Inverse scaler returns predictions to target scale.",
+        "Evaluator reports MSE, MAE, and R2."
+      ],
+      "output": "A reconstructed depth/video feature vector.",
+      "junior_tip": "This is feature-level imagination: can the model infer what another sensor would see?",
+      "failure_mode": "This reconstructs compressed features, not raw pixels, depth maps, meshes, NeRFs, or Gaussian splats.",
+      "task": "modality_reconstruction",
+      "metric": {
+        "key": "r2",
+        "name": "R2",
+        "direction": "higher",
+        "minimal": -0.016022846771134747,
+        "neural_mlp": -0.010198171891414143
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "temporal_order": {
+      "plain_goal": "Tell whether two nearby windows are in the correct time order.",
+      "case_study": "If window A shows reaching and window B shows pouring, the model should distinguish A then B from B then A.",
+      "input": "A pair of adjacent window vectors, plus their difference vector.",
+      "middle_modules": [
+        "Pair builder creates correct-order and reversed-order examples.",
+        "Feature combiner concatenates first window, second window, and their difference.",
+        "Binary classifier predicts correct vs reversed.",
+        "Evaluator reports F1, precision, and recall.",
+        "Diagnostic reader interprets whether features encode local time direction."
+      ],
+      "output": "A binary label: correct order or reversed order.",
+      "junior_tip": "This asks whether the representation knows which moment came first.",
+      "failure_mode": "It only tests local ordering, not long-term planning or causality.",
+      "task": "temporal_order",
+      "metric": {
+        "key": "f1",
+        "name": "F1",
+        "direction": "higher",
+        "minimal": 0.5487364620938628,
+        "neural_mlp": 0.8717948717948718
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    },
+    "misalignment_detection": {
+      "plain_goal": "Detect when modalities that should match are shifted out of sync.",
+      "case_study": "Motion from a pouring moment is paired with video/depth from several windows later. The task asks the model to detect that mismatch.",
+      "input": "A motion-side feature group and a visual/depth-side feature group, either aligned or artificially shifted.",
+      "middle_modules": [
+        "Alignment builder creates positive pairs from the same time window.",
+        "Shift builder creates negative pairs by offsetting one modality group.",
+        "Feature combiner joins both sides into one example.",
+        "Binary classifier predicts aligned vs misaligned.",
+        "Evaluator reports F1 and accuracy."
+      ],
+      "output": "A binary label: aligned or shifted.",
+      "junior_tip": "This is a synchronization alarm for multimodal data.",
+      "failure_mode": "Synthetic shifts are useful diagnostics but do not solve calibration, reconstruction, or mapping by themselves.",
+      "task": "misalignment_detection",
+      "metric": {
+        "key": "f1",
+        "name": "F1",
+        "direction": "higher",
+        "minimal": 0.4865671641791045,
+        "neural_mlp": 0.7335243553008597
+      },
+      "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files"
+    }
+  }
+}

scripts/task_walkthroughs.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""Generate junior-friendly walkthroughs for each Xperience-10M task."""
+
+from __future__ import annotations
+
+import json
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any
+
+from research_direction_taxonomy import METRIC_SPECS, fmt_metric
+
+
+ROOT = Path(__file__).resolve().parents[1]
+RESULTS = ROOT / "results" / "episode_task_suite"
+OUT_DIR = RESULTS / "task_walkthroughs"
+DOCS_DATA = ROOT / "docs" / "data"
+SUMMARY_REPORT = RESULTS / "summary_report.json"
+
+
+TASK_WALKTHROUGHS: OrderedDict[str, dict[str, Any]] = OrderedDict(
+    [
+        (
+            "timeline_action",
+            {
+                "plain_goal": "Look at one short multimodal window and name what action is happening now.",
+                "case_study": "In the coffee-making sample, if the 20-frame window is during a pouring moment, the task asks the model to output an action such as Pour coffee or Pour milk into coffee.",
+                "input": "One 20-frame window represented by the current 8,378-d feature vector: video/depth summaries, pose, SLAM/camera pose, motion capture, IMU, calibration, and language-derived context.",
+                "middle_modules": [
+                    "Window builder slices the episode into short overlapping windows.",
+                    "Feature assembler concatenates all current feature blocks.",
+                    "Label builder reads the action annotation for the center of the window.",
+                    "Classifier head maps the window vector to one action class.",
+                    "Evaluator compares predicted action labels against the held-out chronological segment.",
+                ],
+                "output": "A single action class for the current window.",
+                "junior_tip": "This is like asking: given this tiny movie clip plus sensor readings, what is the person doing right now?",
+                "failure_mode": "The one-episode chronological split contains future action classes that were not present in training, so low test macro-F1 is expected.",
+            },
+        ),
+        (
+            "timeline_subtask",
+            {
+                "plain_goal": "Predict the higher-level task stage for the current window.",
+                "case_study": "A pouring action may belong to a broader subtask such as preparing or pouring a drink. The model predicts that broader stage instead of a fine action.",
+                "input": "The same all-modality 8,378-d window vector used by action recognition.",
+                "middle_modules": [
+                    "Window builder creates the current temporal slice.",
+                    "Feature assembler keeps all available modality blocks.",
+                    "Subtask label builder maps the current timestamp to a subtask annotation.",
+                    "Classifier head predicts the subtask class.",
+                    "Evaluator reports class-balanced scores so rare subtasks matter.",
+                ],
+                "output": "A single subtask label for the current window.",
+                "junior_tip": "Action is the verb; subtask is the chapter of the activity.",
+                "failure_mode": "Single-episode ordering means some later subtasks appear only in test, so this is a pipeline check rather than a general benchmark.",
+            },
+        ),
+        (
+            "transition_detection",
+            {
+                "plain_goal": "Detect whether the current window is near a boundary between actions.",
+                "case_study": "When the demonstrator changes from preparing to pouring, the model should flag a boundary instead of a steady action window.",
+                "input": "One all-modality window vector plus labels derived from action-change timestamps.",
+                "middle_modules": [
+                    "Boundary builder scans action labels over time and marks windows near a change.",
+                    "Feature assembler supplies all current modality features.",
+                    "Binary classifier predicts steady vs boundary.",
+                    "Boundary matcher checks whether predicted boundary times are close to true boundary times.",
+                    "Evaluator reports macro-F1 and timing error, not just accuracy.",
+                ],
+                "output": "A binary label: boundary or steady.",
+                "junior_tip": "This is the model's way of saying: something just changed here.",
+                "failure_mode": "Boundaries are rare, so high accuracy can be misleading if the model predicts steady too often.",
+            },
+        ),
+        (
+            "next_action",
+            {
+                "plain_goal": "Use the current window to guess the action that will happen shortly after it.",
+                "case_study": "If a window shows the person preparing to pour, the target can be the action 20 frames later, such as the start of pouring.",
+                "input": "The current all-modality window vector at time t.",
+                "middle_modules": [
+                    "Window builder picks a current time window.",
+                    "Future label builder shifts the action target by 20 frames.",
+                    "Feature assembler uses only current information, not future features.",
+                    "Classifier head predicts the future action class.",
+                    "Evaluator checks whether the future action label is correct.",
+                ],
+                "output": "A single action class for t+20 frames.",
+                "junior_tip": "This is short-horizon intention prediction: what will the person do next?",
+                "failure_mode": "The public sample has unseen future classes in the chronological test split, which makes this very hard with one episode.",
+            },
+        ),
+        (
+            "hand_trajectory_forecast",
+            {
+                "plain_goal": "Predict where the hands will move over the next few frames.",
+                "case_study": "When the hand is moving toward a cup or bottle, the model predicts the future 3D hand-joint path.",
+                "input": "The current all-modality window vector at time t.",
+                "middle_modules": [
+                    "Window builder chooses the current sensor window.",
+                    "Target builder extracts future left/right hand 3D joints from motion capture.",
+                    "Regression head predicts a continuous trajectory, not a class label.",
+                    "Output reshaper interprets the vector as future frames and joints.",
+                    "Evaluator computes MPJPE, the average 3D joint-position error.",
+                ],
+                "output": "A future trajectory vector for left and right hand joints.",
+                "junior_tip": "Instead of naming an action, this task draws the next hand path in 3D.",
+                "failure_mode": "It is still a window-level forecast, not a full policy or long-horizon motion generator.",
+            },
+        ),
+        (
+            "contact_prediction",
+            {
+                "plain_goal": "Predict whether the body or hand is in contact with something.",
+                "case_study": "During manipulation, the hand may touch a cup, table, or bottle. The task asks whether any contact is happening.",
+                "input": "Non-contact and non-caption feature blocks, so the answer is not directly leaked from the target labels.",
+                "middle_modules": [
+                    "Feature selector removes contact-label and caption-label blocks.",
+                    "Target builder converts contact annotations into a binary label.",
+                    "Binary classifier predicts contact vs no contact.",
+                    "Evaluator reports macro-F1 and accuracy.",
+                    "Degeneracy checker records whether only one class appears.",
+                ],
+                "output": "A binary contact label.",
+                "junior_tip": "This is a simple physical-interaction probe: is the person touching something now?",
+                "failure_mode": "The current public sample is degenerate for this task because one class dominates, so perfect score does not mean the model learned contact physics.",
+            },
+        ),
+        (
+            "object_relevance",
+            {
+                "plain_goal": "Predict which objects matter in the current window.",
+                "case_study": "If the person is pouring milk into coffee, relevant objects may include milk, cup, coffee, or container-like items.",
+                "input": "Non-caption feature blocks, so the model must infer objects from sensors rather than copying the caption words.",
+                "middle_modules": [
+                    "Object vocabulary builder collects object labels from annotations.",
+                    "Feature selector removes caption-derived label blocks.",
+                    "Multi-label target builder creates a multi-hot object vector.",
+                    "Sigmoid heads predict each object's relevance independently.",
+                    "Evaluator reports micro-F1 and exact-match quality.",
+                ],
+                "output": "A multi-label object set for the current window.",
+                "junior_tip": "A window can involve more than one object, so this is not a one-class classifier.",
+                "failure_mode": "Object labels are sparse and language-derived, so this is currently a weak object-centric probe.",
+            },
+        ),
+        (
+            "caption_grounding",
+            {
+                "plain_goal": "Given a text-like query from annotation, find the matching time window.",
+                "case_study": "A query like Pour milk into coffee should rank the windows from the actual pouring moment higher than unrelated windows.",
+                "input": "Caption/object/interaction query features and a set of candidate sensor-window features.",
+                "middle_modules": [
+                    "Query builder converts annotation words into a compact query representation.",
+                    "Candidate builder gathers held-out sensor windows.",
+                    "Projection head maps sensor windows into the query space.",
+                    "Ranker scores candidates by cosine similarity.",
+                    "Evaluator reports MRR and top-k retrieval accuracy.",
+                ],
+                "output": "A ranked list of windows, with the correct matching window ideally near rank 1.",
+                "junior_tip": "This is search: type a description, retrieve the matching moment.",
+                "failure_mode": "Bag-of-objects text features are too simple for rich language grounding.",
+            },
+        ),
+        (
+            "cross_modal_retrieval",
+            {
+                "plain_goal": "Use one group of modalities to retrieve the matching window from another group.",
+                "case_study": "Use motion, IMU, and camera-pose signals from a pouring moment to retrieve the matching depth/video representation for that same moment.",
+                "input": "Query side: motion, IMU, and camera/pose features. Candidate side: depth and video features.",
+                "middle_modules": [
+                    "Feature splitter separates query modalities from target modalities.",
+                    "Projection head maps the query vector into target-modality space.",
+                    "Candidate index stores target vectors from held-out windows.",
+                    "Ranker retrieves nearest candidates by cosine similarity.",
+                    "Evaluator reports MRR, top-1, top-5, and top-10 accuracy.",
+                ],
+                "output": "A ranked list of candidate depth/video windows.",
+                "junior_tip": "This checks whether different sensors agree about the same moment in time.",
+                "failure_mode": "Good retrieval means useful alignment signal, but it is not yet 3D reconstruction or rendering.",
+            },
+        ),
+        (
+            "modality_reconstruction",
+            {
+                "plain_goal": "Predict one modality feature block from other modality blocks.",
+                "case_study": "Given motion, IMU, and camera-pose signals while the hand moves, predict the matching depth/video feature vector.",
+                "input": "Motion, IMU, and camera/pose features as input; depth/video features as the regression target.",
+                "middle_modules": [
+                    "Feature splitter defines source and target modality blocks.",
+                    "Scaler normalizes source and target vectors using train statistics.",
+                    "Regression head predicts the target feature vector.",
+                    "Inverse scaler returns predictions to target scale.",
+                    "Evaluator reports MSE, MAE, and R2.",
+                ],
+                "output": "A reconstructed depth/video feature vector.",
+                "junior_tip": "This is feature-level imagination: can the model infer what another sensor would see?",
+                "failure_mode": "This reconstructs compressed features, not raw pixels, depth maps, meshes, NeRFs, or Gaussian splats.",
+            },
+        ),
+        (
+            "temporal_order",
+            {
+                "plain_goal": "Tell whether two nearby windows are in the correct time order.",
+                "case_study": "If window A shows reaching and window B shows pouring, the model should distinguish A then B from B then A.",
+                "input": "A pair of adjacent window vectors, plus their difference vector.",
+                "middle_modules": [
+                    "Pair builder creates correct-order and reversed-order examples.",
+                    "Feature combiner concatenates first window, second window, and their difference.",
+                    "Binary classifier predicts correct vs reversed.",
+                    "Evaluator reports F1, precision, and recall.",
+                    "Diagnostic reader interprets whether features encode local time direction.",
+                ],
+                "output": "A binary label: correct order or reversed order.",
+                "junior_tip": "This asks whether the representation knows which moment came first.",
+                "failure_mode": "It only tests local ordering, not long-term planning or causality.",
+            },
+        ),
+        (
+            "misalignment_detection",
+            {
+                "plain_goal": "Detect when modalities that should match are shifted out of sync.",
+                "case_study": "Motion from a pouring moment is paired with video/depth from several windows later. The task asks the model to detect that mismatch.",
+                "input": "A motion-side feature group and a visual/depth-side feature group, either aligned or artificially shifted.",
+                "middle_modules": [
+                    "Alignment builder creates positive pairs from the same time window.",
+                    "Shift builder creates negative pairs by offsetting one modality group.",
+                    "Feature combiner joins both sides into one example.",
+                    "Binary classifier predicts aligned vs misaligned.",
+                    "Evaluator reports F1 and accuracy.",
+                ],
+                "output": "A binary label: aligned or shifted.",
+                "junior_tip": "This is a synchronization alarm for multimodal data.",
+                "failure_mode": "Synthetic shifts are useful diagnostics but do not solve calibration, reconstruction, or mapping by themselves.",
+            },
+        ),
+    ]
+)
+
+
+def load_summary() -> dict[str, Any]:
+    return json.loads(SUMMARY_REPORT.read_text(encoding="utf-8"))
+
+
+def metric(summary: dict[str, Any], task: str, family: str) -> float | None:
+    task_metrics = summary.get(family, {}).get(task, {})
+    key = METRIC_SPECS[task][0]
+    value = task_metrics.get(key)
+    return float(value) if value is not None else None
+
+
+def build_payload(summary: dict[str, Any]) -> dict[str, Any]:
+    tasks = OrderedDict()
+    for task, spec in TASK_WALKTHROUGHS.items():
+        metric_key, metric_name, direction = METRIC_SPECS[task]
+        minimal = metric(summary, task, "tasks")
+        neural = metric(summary, task, "neural_tasks")
+        tasks[task] = {
+            **spec,
+            "task": task,
+            "metric": {
+                "key": metric_key,
+                "name": metric_name,
+                "direction": direction,
+                "minimal": minimal,
+                "neural_mlp": neural,
+            },
+            "module_summary": "input window -> feature/target builder -> baseline head -> evaluator -> artifact files",
+        }
+    return {
+        "source": "results/episode_task_suite/summary_report.json",
+        "scope": {
+            "episode_count": 1,
+            "num_frames": summary.get("num_frames"),
+            "num_windows": summary.get("num_windows"),
+            "feature_dim": summary.get("feature_dim"),
+            "window_frames": summary.get("window_frames"),
+            "stride_frames": summary.get("stride_frames"),
+            "warning": "These walkthroughs explain task contracts on one public sample episode; they are not cross-episode performance claims.",
+        },
+        "shared_pipeline": [
+            "Read annotation.hdf5 and synchronized video-derived features.",
+            "Slice the episode into 20-frame windows with stride 5.",
+            "Build an 8,378-d current feature vector from available modality blocks.",
+            "Construct a task-specific target from labels, future frames, paired windows, or modality splits.",
+            "Train a minimal head and, when enabled, a neural MLP head.",
+            "Write metrics, predictions, and model artifacts for review.",
+        ],
+        "tasks": tasks,
+    }
+
+
+def write_markdown(payload: dict[str, Any]) -> None:
+    lines = [
+        "# Junior-Friendly 12-Task Walkthroughs",
+        "",
+        "This file explains every task in the Xperience-10M episode suite as an input -> process -> output pipeline.",
+        "It is generated by `scripts/task_walkthroughs.py` from committed metrics plus hand-audited task explanations.",
+        "",
+        "## Shared Pipeline",
+        "",
+    ]
+    for step in payload["shared_pipeline"]:
+        lines.append(f"- {step}")
+    lines.extend(["", "## Task Walkthroughs", ""])
+
+    for task, spec in payload["tasks"].items():
+        metric = spec["metric"]
+        minimal = fmt_metric(metric["minimal"])
+        neural = fmt_metric(metric["neural_mlp"])
+        lines.extend(
+            [
+                f"### `{task}`",
+                "",
+                f"**Goal:** {spec['plain_goal']}",
+                "",
+                f"**Case study:** {spec['case_study']}",
+                "",
+                f"**Input:** {spec['input']}",
+                "",
+                "**Middle process modules:**",
+            ]
+        )
+        for module in spec["middle_modules"]:
+            lines.append(f"- {module}")
+        lines.extend(
+            [
+                "",
+                f"**Output:** {spec['output']}",
+                "",
+                f"**Metric:** {metric['name']} ({metric['direction']} is better). Minimal `{minimal}`, neural MLP `{neural}`.",
+                "",
+                f"**Junior mental model:** {spec['junior_tip']}",
+                "",
+                f"**Current limitation:** {spec['failure_mode']}",
+                "",
+            ]
+        )
+
+    (OUT_DIR / "TASK_WALKTHROUGHS.md").write_text(
+        "\n".join(lines).rstrip() + "\n", encoding="utf-8"
+    )
+
+
+def main() -> int:
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    DOCS_DATA.mkdir(parents=True, exist_ok=True)
+    payload = build_payload(load_summary())
+    text = json.dumps(payload, indent=2, ensure_ascii=False)
+    (OUT_DIR / "task_walkthroughs.json").write_text(text + "\n", encoding="utf-8")
+    (DOCS_DATA / "task_walkthroughs.json").write_text(text + "\n", encoding="utf-8")
+    write_markdown(payload)
+    print(f"Wrote {OUT_DIR / 'task_walkthroughs.json'}")
+    print(f"Wrote {OUT_DIR / 'TASK_WALKTHROUGHS.md'}")
+    print(f"Wrote {DOCS_DATA / 'task_walkthroughs.json'}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())