Update README and adapter code

README.md

@@ -14,11 +14,11 @@ Delta Flow (ImageWAM / HumanWAM whole-body delta-flow policy) checkpoints traine
 
 | Folder | Task | Robot | Cameras (model input) | Global batch | Proprio augmentation | Checkpoints |
 |---|---|---|---|---|---|---|
-| — | no benchmark checkpoints published yet | | | | | |
+| `b6-pedal-bin/` | B6 — pick up a chip barrel, step on the pedal bin, drop it in | Unitree G1 (Inspire hands) | ego_view, chest | — | aligned (GR00T A20 recipe) | `epoch-030`, `epoch-040` |
 
 ## What an epoch folder contains
 
-Every `epoch-XXX/` folder is self-contained for evaluation and deployment: weights, model configuration, normalization
+Every checkpoint folder (`epoch-XXX/`, or `step-XXXXXX/` for runs trained for a fixed number of steps) is self-contained for evaluation and deployment: weights, model configuration, normalization
 statistics and `protocol.json` (task, data, input/output dimensions, cameras, batch, steps, augmentation, file list).
 Simple training records are included for reproducibility (training plan, training log, configs, metrics); optimizer /
 scheduler / RNG / DeepSpeed resume state is not. `code/` holds the adapter code used for training and inference

code/hb_deltaflow/deltaflow_check_final.py

@@ -0,0 +1,78 @@
+"""Verify a finished Delta-flow 40-epoch run; node 0 then writes R/deltaflow-complete.json.
+
+    python deltaflow_check_final.py <run_root R> [--write]      exit 0 = complete, 1 = not complete
+Checks: 32 finish receipts at global_step = 40 x updates_per_epoch; weights for epochs 10/20/30/40 present and
+non-empty; exactly one training state left (the final step) with the full ZeRO-1 shard set.
+"""
+import argparse
+import json
+from pathlib import Path
+import sys
+
+WORLD, EPOCHS, EVERY = 32, 40, 10
+
+
+def problems(root):
+    found = []
+    receipt = json.loads((root / 'data-verified.json').read_text())
+    u = int(receipt['updates_per_epoch'])
+    total = EPOCHS * u
+    if receipt.get('fixed_steps'):  # 2026-11-12: fixed-step runs (8000 steps, checkpoints 6000 / 8000)
+        total = int(receipt['max_steps'])
+    out = root / 'run' / 'production'
+    for rank in range(WORLD):
+        path = out / f'finish-rank-{rank:02d}.json'
+        if not path.is_file():
+            found.append(f'missing {path.name}')
+            continue
+        status = json.loads(path.read_text())
+        if status.get('rank') != rank or status.get('global_step') != total:
+            found.append(f'bad receipt {path.name}: {status}')
+        elif status.get('resumed_from_step', 0) == 0 and status.get('optimizer_steps') != total:
+            found.append(f'optimizer step count differs in {path.name}: {status}')
+    weights = [out / 'checkpoints' / 'weights' / f'step_{e * u:06d}.pt' for e in range(EVERY, EPOCHS + 1, EVERY)]
+    if receipt.get('fixed_steps'):
+        weights = [out / 'checkpoints' / 'weights' / f'step_{s:06d}.pt' for s in receipt['save_steps']]
+    for path in weights:
+        if not path.is_file() or path.stat().st_size <= 0:
+            found.append(f'missing weights {path.name}')
+    state_root = out / 'checkpoints' / 'state'
+    states = sorted(p.name for p in state_root.iterdir() if p.is_dir()) if state_root.is_dir() else []
+    final = state_root / f'step_{total:06d}'
+    if states != [final.name]:
+        found.append(f'expected only state {final.name}, found {states}')
+    shards = list((final / 'pytorch_model').glob('*_optim_states.pt'))
+    model = final / 'pytorch_model' / 'mp_rank_00_model_states.pt'
+    if (len(shards) != WORLD or not model.is_file() or not (final / 'trainer_state.json').is_file()
+            or any(p.stat().st_size <= 0 for p in [*shards, model] if p.is_file())):
+        found.append(f'final training state incomplete ({len(shards)} optimizer shards)')
+    return found, dict(weights=[str(p) for p in weights], state=str(final), optimizer_shards=len(shards),
+                       updates_per_epoch=u, max_steps=total, train_episode_ids='0-99',
+                       save_steps=receipt.get('save_steps'), fixed_steps=bool(receipt.get('fixed_steps')))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('root', type=Path)
+    parser.add_argument('--write', action='store_true', help='write deltaflow-complete.json when complete')
+    args = parser.parse_args()
+    root = args.root.resolve()
+    try:
+        found, summary = problems(root)
+    except (OSError, ValueError, KeyError) as error:
+        print(f'DELTAFLOW_INCOMPLETE {root.name}: {type(error).__name__}: {error}', flush=True)
+        return 1
+    if found:
+        print(f'DELTAFLOW_INCOMPLETE {root.name}: ' + '; '.join(found[:8]), flush=True)
+        return 1
+    if args.write:
+        target = root / 'deltaflow-complete.json'
+        pending = root / 'deltaflow-complete.json.tmp'
+        pending.write_text(json.dumps(summary, indent=2) + '\n')
+        pending.replace(target)
+    print(f'DELTAFLOW_COMPLETE {root.name}: checkpoint weights + final state verified', flush=True)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

code/hb_deltaflow/deltaflow_supervise.py

@@ -0,0 +1,217 @@
+"""Per-node supervisor for one Delta-flow production run on 4 nodes x 8 GPUs (adapted from launch_supervised.py).
+
+Usage (called by deltaflow_task.sh on every node, DLC env RANK/WORLD_SIZE/MASTER_ADDR present):
+    python deltaflow_supervise.py <run_root R> <session> <port_base>
+Up to 3 attempts. Before each attempt node 0 writes a plan: resume from the newest complete training state in
+R/run/production/checkpoints/state (saved at epoch 10/20/30), or, when none exists, move any partial output aside
+and start fresh. A node that sees a peer fail stops its own launcher; a 30-minute all-idle stall stops all.
+NAS barriers live in R/run/retry/s<session>/attempt-<n>/. Exit 0 only when all four launchers exited 0.
+"""
+import json
+import os
+from pathlib import Path
+import re
+import signal
+import subprocess
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+R = Path(sys.argv[1]).resolve()
+SESSION = int(sys.argv[2])
+PORT_BASE = int(sys.argv[3])
+NODE = int(os.environ['RANK'])
+NODES, WORLD, ATTEMPTS = 4, 32, 3
+RUN = R / 'run'
+OUT = RUN / 'production'
+STATE = OUT / 'checkpoints' / 'state'
+CURRENT = {}
+
+
+def log(*args):
+    print(time.strftime('%Y-%m-%d %H:%M:%S'), f'[supervise node {NODE}]', *args, flush=True)
+
+
+def write(path, text):
+    pending = path.with_name(f'{path.name}.tmp{os.getpid()}')
+    pending.write_text(text)
+    pending.replace(path)
+
+
+def wait_for_files(paths, seconds=900):
+    deadline = time.monotonic() + seconds
+    while not all(path.is_file() for path in paths):
+        if time.monotonic() >= deadline:
+            missing = [str(p) for p in paths if not p.is_file()]
+            raise TimeoutError(f'Four nodes did not reach a shared barrier; missing {missing}')
+        time.sleep(2)
+
+
+def gpu_apps():
+    return subprocess.check_output(['nvidia-smi', '--query-compute-apps=pid', '--format=csv,noheader'],
+                                   text=True, timeout=20).strip()
+
+
+def gpu_idle():
+    try:
+        result = subprocess.check_output(['nvidia-smi', '--query-gpu=utilization.gpu', '--format=csv,noheader,nounits'],
+                                         text=True, timeout=8)
+        utilization = [int(line.strip()) for line in result.splitlines()]
+        return len(utilization) == 8 and max(utilization) == 0
+    except (subprocess.SubprocessError, ValueError):
+        return False
+
+
+def complete_state(path):
+    return ((path / 'trainer_state.json').is_file()
+            and (path / 'pytorch_model' / 'mp_rank_00_model_states.pt').is_file()
+            and len(list((path / 'pytorch_model').glob('*_optim_states.pt'))) == WORLD)
+
+
+def newest_state():
+    if not STATE.is_dir():
+        return None
+    found = []
+    for path in STATE.iterdir():
+        match = re.fullmatch(r'step_(\d+)', path.name)
+        if match and path.is_dir() and complete_state(path):
+            found.append((int(match.group(1)), path))
+    return max(found)[1] if found else None
+
+
+def training_idle(attempt_dir, now):
+    threshold = now - 1800
+    for rank in range(NODES):
+        path = attempt_dir / f'gpu-idle-{rank}.json'
+        if not path.is_file():
+            return False
+        report = json.loads(path.read_text())
+        if report['sampled'] < now - 90 or report['idle_since'] is None or report['idle_since'] > threshold:
+            return False
+    activity = list(attempt_dir.glob('node-*.log')) + list((OUT / 'checkpoints').rglob('*'))
+    if not activity:
+        return False
+    for path in activity:
+        try:
+            if path.stat().st_mtime > threshold:
+                return False
+        except FileNotFoundError:
+            return False
+    return True
+
+
+def wait_for_process(process, peers, attempt_dir):
+    next_sample, idle_since = 0.0, None
+    stalled = attempt_dir / 'training-stalled'
+    while process.poll() is None:
+        if time.monotonic() >= next_sample:
+            now = time.time()
+            idle_since = (idle_since if idle_since is not None else now) if gpu_idle() else None
+            write(attempt_dir / f'gpu-idle-{NODE}.json', json.dumps({'sampled': now, 'idle_since': idle_since}))
+            next_sample = time.monotonic() + 30
+            if NODE == 0 and training_idle(attempt_dir, now):
+                write(stalled, 'All four nodes idle and no log/checkpoint progress for 30 minutes.\n')
+        if stalled.exists() or any(path.is_file() and path.read_text().strip() != '0' for path in peers):
+            log('peer failure or stall detected; stopping local launcher')
+            try:
+                os.killpg(process.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+            try:
+                return process.wait(timeout=120)
+            except subprocess.TimeoutExpired:
+                os.killpg(process.pid, signal.SIGKILL)
+                return process.wait(timeout=60)
+        time.sleep(2)
+    return process.returncode
+
+
+def release_gpus():
+    deadline = time.monotonic() + 300
+    while gpu_apps():
+        if time.monotonic() >= deadline:
+            raise TimeoutError('GPU processes did not exit after a failed attempt')
+        if time.monotonic() >= deadline - 180:
+            subprocess.call(['pkill', '-9', '-f', 'scripts/wholebody/train_deltaflow.py'])
+        time.sleep(5)
+
+
+def plan_attempt(attempt, attempt_dir):
+    """Node 0 only: decide resume vs fresh start (all nodes are idle at this point)."""
+    state = newest_state()
+    if state is not None:
+        plan = {'resume': str(state), 'step': int(state.name.split('_')[1])}
+    else:
+        if OUT.exists():
+            aside = RUN / f'discarded-s{SESSION}-a{attempt}-{time.strftime("%Y%m%dT%H%M%S")}'
+            OUT.rename(aside)
+            log('no complete training state; partial output moved to', aside)
+        plan = {'resume': None, 'step': 0}
+    write(attempt_dir / 'plan.json', json.dumps(plan) + '\n')
+
+
+def run():
+    if NODE not in range(NODES):
+        raise ValueError('Unexpected node rank')
+    session_root = RUN / 'retry' / f's{SESSION}'
+    for attempt in range(1, ATTEMPTS + 1):
+        attempt_dir = session_root / f'attempt-{attempt}'
+        attempt_dir.mkdir(parents=True, exist_ok=True)
+        ready = [attempt_dir / f'ready-{rank}' for rank in range(NODES)]
+        done = [attempt_dir / f'exit-{rank}' for rank in range(NODES)]
+        CURRENT['exit'] = done[NODE]
+        if ready[NODE].exists():
+            raise RuntimeError(f'This node already joined {attempt_dir} (session counters out of sync?)')
+        deadline = time.monotonic() + 180
+        while gpu_apps():
+            if time.monotonic() >= deadline:
+                raise RuntimeError('GPUs busy before launch')
+            time.sleep(5)
+        write(ready[NODE], f'{os.getpid()}\n')
+        wait_for_files(ready)
+        if NODE == 0:
+            plan_attempt(attempt, attempt_dir)
+        wait_for_files([attempt_dir / 'plan.json'], seconds=300)
+        plan = json.loads((attempt_dir / 'plan.json').read_text())
+        if any(path.exists() for path in done):
+            raise RuntimeError('A result exists before the attempt began')
+        port = PORT_BASE + 3 * ((SESSION - 1) % 3) + attempt - 1
+        log(f'attempt {attempt} port {port} resume={plan["resume"]}')
+        with (attempt_dir / f'node-{NODE}.log').open('ab') as stream:
+            process = subprocess.Popen(['bash', str(HERE / 'deltaflow_attempt.sh'), str(R), str(port),
+                                        plan['resume'] or 'none'],
+                                       stdin=subprocess.DEVNULL, stdout=stream, stderr=subprocess.STDOUT,
+                                       start_new_session=True)
+            status = wait_for_process(process, [path for i, path in enumerate(done) if i != NODE], attempt_dir)
+        log(f'attempt {attempt} local launcher exit {status}')
+        write(done[NODE], f'{status}\n')
+        wait_for_files(done, seconds=1800)
+        if all(path.read_text().strip() == '0' for path in done):
+            return 0
+        if attempt < ATTEMPTS:
+            release_gpus()
+            drained = [attempt_dir / f'gpu-released-{rank}' for rank in range(NODES)]
+            write(drained[NODE], 'idle\n')
+            wait_for_files(drained, seconds=600)
+    return 1
+
+
+def main():
+    log_dir = RUN / 'node-logs'
+    log_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        result = run()
+    except Exception as error:  # noqa: BLE001 - report every failure to the NAS and exit nonzero
+        write(log_dir / f's{SESSION}-supervisor-error-{NODE}.json',
+              json.dumps({'type': type(error).__name__, 'detail': str(error)}) + '\n')
+        log('ERROR', type(error).__name__, error)
+        result = 1
+        exit_file = CURRENT.get('exit')
+        if exit_file is not None and not exit_file.exists():
+            write(exit_file, '1\n')      # lets the peers stop their launchers instead of waiting for timeouts
+    write(log_dir / f's{SESSION}-node-{NODE}.exit', f'{result}\n')
+    return result
+
+
+if __name__ == '__main__':
+    sys.exit(main())

code/hb_deltaflow/h2_hbaug.py

@@ -0,0 +1,119 @@
+"""A18 (H2 + Sharpa hands) Delta-flow loader with augmentation spec v2. NO joint velocity.
+
+Installed by prepare_deltaflow_a18.py as imagewam/datasets/h2_hbaug.py in the H2 code copy (HumanWAM-h2), next to
+an unchanged copy of $G/hb_groot/hb_aug_v2.py. Builds on H2PourDataset of a18-h2-pour-from-scratch-20261108:
+same cameras (head + chest; the collection also records wrist and third_person, unused as before), same
+normalization file format (q01/q99 of state78 = 75 joints + gravity3, action75 = body_target31 + hands44),
+same 16-step action chunk / history and t+16 image target. Changes:
+  - visual: hb_aug_v2.augment on [T=2, V=2, 3, 224, 224] (15 effects, one boosted to 1.5x per sample, colour shared,
+    rotation/light/WB per camera on t and t+16, sensor/optics only on the observation frame t);
+  - proprio (2026-11-12, aligned with GR00T A20; H2 body = state[0:31] incl. waist and head):
+    hb_aug_v2.perturb_joints per sample (+-2 deg bias + N(0, 0.25 deg) noise clipped at 3 sigma), no delay,
+    no history drop; hands, gravity and every label untouched.
+Model input: proprio[16, 78] = normalized(75 joints + gravity 3), exactly the state of the original H2 model
+(h2_pour_delta.py, HF g1-basket-transfer-imagewam-deltaflow76 h2-a18-pour-water/epoch-040: proprio_dim 78).
+User rule 2026-11-10: no joint-velocity channels in any training; any velocity argument is an error.
+"""
+from __future__ import annotations
+
+import math
+import os
+
+import numpy as np
+import torch
+
+from . import hb_aug_v2
+from .h2_pour import ACTION_DIM, CAMERAS, STATE_DIM, H2PourDataset
+from .wholebody import window_indices
+
+BODY = 31
+SPEC_VERSION = "hb-aug-v2-20261109"
+# 2026-11-12 (user): proprio aligned with GR00T's A20 basket-transfer training (hb_groot/hb_launch.py):
+# hb_aug_v2.perturb_joints on the 31 body joints per sample, no delay, no history drop.
+PROPRIO_SPEC = {"enabled": True, "joint_bias_degrees": 2.0, "joint_noise_std_degrees": 0.25,
+                "delay_probability": 0.0, "max_delay_control_cycles": 0, "control_hz": 30, "recording_hz": 30,
+                "history_drop_probability": 0.0, "bias_scope": "per_sample",
+                "implementation": "hb_aug_v2.perturb_joints"}
+if STATE_DIM != 78:
+    raise ImportError(f"H2 state must be 78-D (75 joints + gravity 3), h2_pour says {STATE_DIM}")
+
+
+class H2HBAugV2Dataset(H2PourDataset):
+    def __init__(self, *, image_augmentation, proprio_augmentation, **kwargs):
+        velocity_args = sorted(k for k in kwargs if "velocity" in k)
+        if velocity_args:
+            raise ValueError(f"Joint velocity is not allowed in the model input (got {velocity_args})")
+        image_policy = dict(image_augmentation)
+        proprio_policy = dict(proprio_augmentation)
+        if hb_aug_v2.VERSION != SPEC_VERSION or image_policy.get("version") != SPEC_VERSION:
+            raise ValueError(f"Expected augmentation {SPEC_VERSION}, got module {hb_aug_v2.VERSION} / "
+                             f"config {image_policy.get('version')}")
+        if image_policy.get("enabled") is not True or "seed" not in image_policy:
+            raise ValueError("Augmentation v2 must be enabled and seeded")
+        for key, value in PROPRIO_SPEC.items():
+            if proprio_policy.get(key) != value:
+                raise ValueError(f"proprio_augmentation.{key}={proprio_policy.get(key)!r}, spec v2 needs {value!r}")
+        if list(proprio_policy.get("affected_angle_channels", [])) != list(range(BODY)) or "seed" not in proprio_policy:
+            raise ValueError("Bias/noise must hit exactly the 31 H2 body joints (state[0:31])")
+        if list(proprio_policy.get("velocity_channels") or []):
+            raise ValueError("velocity_channels must be empty (no joint velocity)")
+        # The parent's own (spec v1) image augmentation stays disabled; hb_aug_v2 replaces it below.
+        super().__init__(image_augmentation=None, **kwargs)
+        self.image_policy, self.proprio_policy = image_policy, proprio_policy
+        self._aug_rng, self._aug_key = None, None
+        self.last_augmentation = {}
+
+    def _rng(self):
+        worker = torch.utils.data.get_worker_info()
+        worker_id = worker.id if worker else 0
+        rank = int(os.environ.get("RANK", "0"))
+        initial = int(torch.initial_seed())
+        key = (os.getpid(), rank, worker_id, initial)
+        if key != self._aug_key:
+            self._aug_rng = np.random.default_rng(np.random.SeedSequence(
+                [int(self.image_policy["seed"]), rank, worker_id, initial % (2 ** 32), initial // (2 ** 32)]))
+            self._aug_key = key
+        return self._aug_rng
+
+    def augment_numeric(self, episode, anchor, state, past, pad, rng):
+        raw = state[anchor].copy()                                  # 75 joints + gravity 3, radians; no delay
+        before = raw[:BODY].astype(np.float64)
+        raw[:BODY] = hb_aug_v2.perturb_joints(raw[:BODY], rng)      # per-sample bias +-2 deg + noise 0.25 deg
+        proprio = self.normalize(raw, "state").astype(np.float32)
+        if proprio.shape != (STATE_DIM,):
+            raise ValueError(f"proprio must be {STATE_DIM}-D (no velocity), got {proprio.shape}")
+        past[pad] = 0                                               # unchanged history, no drop
+        info = dict(delay_recorded_frames=0, state_frame=anchor, anchor_frame=anchor, history_drop_rows=[],
+                    joint_perturbation_degrees=np.degrees(raw[:BODY].astype(np.float64) - before).tolist())
+        return proprio, past, pad, info
+
+    def __getitem__(self, index):
+        if index < 0 or index >= len(self):
+            raise IndexError(index)
+        ep_position = int(np.searchsorted(self.ends, index, side="right"))
+        episode = self.episode_ids[ep_position]
+        anchor = int(index - (self.ends[ep_position - 1] if ep_position else 0))
+        state, action = self.episodes[episode]
+        window = window_indices(anchor, len(action), 16, 16)
+        views = torch.stack([self._frames(episode, c, window["image"].tolist()) for c in CAMERAS], dim=1)
+        rng = self._rng()
+        observation = torch.tensor([True, False])                   # t+16 is the supervised image target
+        views, visual = hb_aug_v2.augment(views, rng, obs_mask=observation)
+        video = (torch.cat(list(views.unbind(1)), dim=-1) * 2 - 1).permute(1, 0, 2, 3).contiguous()
+        future = self.normalize(action[window["action"]], "action")
+        past = self.normalize(action[window["past_action"]], "action")
+        if window["past_action_is_pad"].all():
+            past = np.zeros_like(past)
+        proprio, past, pad, numeric = self.augment_numeric(
+            episode, anchor, state, torch.from_numpy(past), torch.from_numpy(window["past_action_is_pad"].copy()), rng)
+        self.last_augmentation = dict(visual=visual, numeric=numeric)
+        return dict(video=video, action=torch.from_numpy(future), past_action=past,
+                    proprio=torch.from_numpy(np.repeat(proprio[None], 16, axis=0)),
+                    action_is_pad=torch.from_numpy(window["action_is_pad"]), past_action_is_pad=pad,
+                    image_is_pad=torch.from_numpy(window["image_is_pad"]),
+                    proprio_is_pad=torch.zeros(16, dtype=torch.bool),
+                    action_dim_is_pad=torch.zeros(ACTION_DIM, dtype=torch.bool),
+                    proprio_dim_is_pad=torch.zeros(STATE_DIM, dtype=torch.bool),
+                    text_hidden_states=self.text_hidden_states, text_attention_mask=self.text_attention_mask,
+                    prompt=self.prompt, instruction=self.prompt, idx=int(index), episode_index=int(episode),
+                    frame_index=anchor, task_index=0, dataset_index=0)

code/hb_deltaflow/prepare_deltaflow.py

@@ -0,0 +1,418 @@
+"""One-time CPU preparation of the ImageWAM Delta-flow 40-epoch runs (B6 / A3 / A7, 100 episodes each, aug v2).
+
+NO joint velocity (user rule 2026-11-10): the model input is 44-D (body 29 + hands 12 + gravity 3), exactly like the
+reference HF humanoid-benchmark/b6-imagewam-deltaflow76 real30-from-sim60-20261108 (proprio_dim = action_state_dim
+= 44, velocity_channels []). The previous run's YAML is a 73-D (velocity) config: its velocity keys are removed and
+the model dims are set to 44; no velocity cache or statistics are produced, and no_velocity() rejects any leftover.
+
+Run on node 0 (no GPU needed), after deploying this directory to $G/hb_deltaflow:
+    $P/venv/bin/python $G/hb_deltaflow/prepare_deltaflow.py            # all of b6 a3 a7 a18
+    $P/venv/bin/python $G/hb_deltaflow/prepare_deltaflow.py b6         # one task
+    (a18 = H2 is delegated to prepare_deltaflow_a18.py in a separate interpreter; see that file)
+Creates (never touches the old experiments or the datasets):
+    $G/deltaflow-runs/HumanWAM/                 code copy of the last B6 Delta-flow run + 100-episode loader patch,
+                                                hb_aug_v2.py, wholebody_hbaug.py, train_deltaflow.py
+    $G/deltaflow-runs/<task>/{split-manifest.json, stats/, qwen-text/, run/production.yaml, data-verified.json,
+                              prepared.ok}
+Idempotent: finished tasks (prepared.ok) are skipped; a half-prepared task directory is renamed aside and redone.
+"""
+import hashlib
+import json
+import math
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+import yaml
+
+H = Path(__file__).resolve().parent          # $G/hb_deltaflow
+G = H.parent                                 # $P/policies-20261109
+P = G.parent                                 # preflight-20261104T1648Z
+OLD_B6 = P / 'b6-v5t7-ready-start-60ep-20261109'
+OLD_A = P / 'a3-a7-20261109'
+SRC_CODE = OLD_B6 / 'HumanWAM'
+AUG_SRC = G / 'hb_groot' / 'hb_aug_v2.py'
+# The B6 60-epoch copy's wholebody_delta.py hard-codes the 73-D (44 + 29 joint velocity) state; the 44-D reference run
+# real30-from-sim60-20261108 (HF humanoid-benchmark/b6-imagewam-deltaflow76) used the same file with 44 instead.
+REF_DELTA = P / 'real30-from-sim60-20261108' / 'HumanWAM' / 'src/imagewam/wholebody_delta.py'
+REF_DELTA_SHA256 = '523244263496679f7046035f5df3d34590b7086e25173938d8a175dad963b9f3'
+ROOT = G / 'deltaflow-runs'
+CODE = ROOT / 'HumanWAM'
+
+EPISODES, EPOCHS, SAVE_EVERY_EPOCHS, WARMUP_EPOCHS = 100, 40, 10, 2
+WORLD, MICRO = 32, 8
+# 2026-11-12 user: fixed 8000 optimizer steps (no epochs); checkpoints every 2000 steps counted back from the last
+# step, only the last two kept (the last one with its resume state); warmup 5 % (the former 2 of 40 epochs).
+FIXED_STEPS, CKPT_EVERY, KEEP_CKPTS, WARMUP_FRAC = 8000, 2000, 2, 0.05
+
+
+def fixed_schedule(u):
+    total = FIXED_STEPS
+    save_steps = [total - CKPT_EVERY * k for k in range(KEEP_CKPTS - 1, -1, -1)]
+    return total, save_steps, round(WARMUP_FRAC * total), math.ceil(total / u)
+DATASET_TARGET = 'imagewam.datasets.wholebody_hbaug.WholeBodyHBAugV2LeRobotDataset'
+AUG_VERSION = 'hb-aug-v2-20261109'
+AUG_SHA256 = '9f7713cea4f846efcfc924234267ced48210357f419d67915c10b504316bedde'
+TASKS = {
+    'b6': dict(data=OLD_B6 / 'data/deliveries/g1/b6-v5t7-ready-start-20261109', old=OLD_B6 / 'train',
+               control_hz=50, total_episodes=149),
+    'a3': dict(data=OLD_A / 'a3-fridge-open-expert-v1/780fcf1e4bd7db947a8c2d8f7b92e61f24f71b45', old=OLD_A / 'a3',
+               control_hz=30, total_episodes=100),
+    'a7': dict(data=OLD_A / 'a7-cabinet-close-expert-v1/1935a98e8f55d4d1d2d1615ddb97c2679713595c', old=OLD_A / 'a7',
+               control_hz=30, total_episodes=100),
+    # 2026-11-12: tasks without a previous Delta-flow experiment. Template config = the A3 run (same G1 model / loader);
+    # split manifest and instruction cache are generated here. Datasets are aligned with basket-transfer-expert-v1
+    # (identical 41 features / modality, 30 FPS); the fixed first 100 episodes are trained, later ones shelved.
+    'trolley': dict(data=P / 'trolley-push-expert-v1-20261110/data/trolley_push', old=None, control_hz=50,
+                    total_episodes=None, source='trolley-push-expert-v1 @ef9024a'),
+    'basket': dict(data=P / 'basket-current-dynamics-100-v21-b0ff522/data', old=None, control_hz=50,
+                   total_episodes=None, source='basket-transfer-expert-v1 @b0ff522 (current-dynamics-100-v21)'),
+    'b7': dict(data=P / 'b7-black-clothes-hamper-v1-1bb002a/data', old=None, control_hz=50,
+               total_episodes=None, source='b7-black-clothes-hamper-expert-v1 @1bb002a'),
+    'a6': dict(data=P / 'a6-door-pull-v1-cf3ee9b/data/door_pull', old=None, control_hz=50,
+               total_episodes=None, source='door-pull-expert-v1 @cf3ee9b'),
+    'c6': dict(data=P / 'c6-bathroom-door-fetch-v1-3afba69/data', old=None, control_hz=50,
+               total_episodes=None, source='c6-bathroom-door-fetch-expert-v1 @3afba69e'),
+}
+TEMPLATE = OLD_A / 'a3'
+QWEN3 = P / 'hf-inputs/Qwen3-4B'
+FLUX2_SRC = P / 'HumanWAM/third_party/flux2'
+H2_TASKS = ('a18', 'a17')
+# 2026-11-12 (user): every model aligned with GR00T's A20 basket-transfer training (hb_groot/hb_launch.py).
+ALIGNED_PROPRIO = dict(delay_probability=0.0, max_delay_control_cycles=0, history_drop_probability=0.0,
+                       bias_scope='per_sample', implementation='hb_aug_v2.perturb_joints',
+                       aligned_with='GR00T A20 basket-transfer recipe (hb_groot/hb_launch.py), user 2026-11-12')
+
+
+def new_manifest(task, spec, meta, ids):
+    D = spec['data']
+    names = meta['info']['features']['observation.state'].get('names') or []
+    hashes = {rel: sha(D / rel) for rel in ('meta/info.json', 'meta/episodes.jsonl', 'meta/source_episodes.jsonl')
+              if (D / rel).is_file()}
+    stem = spec['source'].split(' ')[0]
+    return dict(train_episode_ids=ids[:EPISODES], validation_episode_ids=ids[EPISODES:], seed=42,
+                provenance_reviewed=True,
+                provenance_note=(f'generated 2026-11-12 by prepare_deltaflow.py for HF {spec["source"]}; one source '
+                                 'group per episode; dataset format checked against basket-transfer-expert-v1'),
+                split_basis='', source_group_by_episode={str(i): f'{stem}-{i:06d}' for i in ids},
+                expected_body_joint_names=list(names[:29]), source_metadata_sha256=hashes)
+# Files of the last B6 Delta-flow code copy that this package builds on (hashes of the reviewed copy).
+SOURCE_SHA256 = {
+    'src/imagewam/datasets/wholebody.py': 'e6460388758187180a28515cb15b666d948387b1b6aff7b026baa2f2e9402ccc',
+    'src/imagewam/datasets/wholebody_velocity.py': 'a5788736652772aea2fcf305b47ca6a6c11e1ea798fe8e2cf7bcdd1a242b23ea',
+    'src/imagewam/datasets/wholebody_augmented_v3.py': '0e34ea3a71dde2f05bd4bd314ec97787bf3d1809c1cedc3dff5e8610b7723366',
+    'src/imagewam/datasets/wholebody_augmented.py': '641bb399f54206fe1c923c4b24fd1b9797787616154915523f10a9480daf7da3',
+    'src/imagewam/trainer.py': 'cdcd48e09d1d7b81cae3a829bd415ed4b53ff1b290aacac1ce2217876f475b1a',
+    'src/imagewam/runtime.py': '3ebc45f61b0c22fb659012a7d76bea671a42e1e528b5c917ae1e8827e88b890b',
+    'src/imagewam/wholebody_delta.py': '20135b5a6cc0378c76d3eb8d958cbc4c3aeb773909b1453081f4fcd6238d36ea',
+    'scripts/wholebody/train_a3a7.py': '2cf154f91de516f96da9b93f4b8e235fab13344461b2aeb5d048e4f78a63dec8',
+    'scripts/accelerate_configs/accelerate_zero1_ds.yaml': '5b9e24f38c199fdff6bbd17981d86e2624f855f707660094c99f711efc8e0833',
+}
+# wholebody.py of the B6 run accepts exactly 149/0 episodes; make it accept exactly episodes 0-99 for training,
+# with any later episodes listed as shelved (validation_episode_ids, never loaded for training or statistics).
+LOADER_PATCHES = [
+    ('STATS_SCHEMA = "wholebody-state41to44-action76-chunk16-train149val0-v1"',
+     'STATS_SCHEMA = "wholebody-state41to44-action76-chunk16-first100-v1"', 1),
+    ('    if (len(train) != 149 or len(val) != 0 or train != sorted(set(train))\n'
+     '            or val != sorted(set(val)) or set(train) & set(val)\n'
+     '            or sorted(train + val) != ids):\n'
+     '        raise ValueError("Require exact disjoint 149/0 episode partition of 149 episodes")\n',
+     '    if (train != list(range(100)) or val != sorted(set(val)) or set(train) & set(val)\n'
+     '            or sorted(train + val) != ids):\n'
+     '        raise ValueError("Require training episodes exactly 0-99; later episodes may only be listed as shelved")\n',
+     1),
+    ('    if train_split_mode != "all_149" or len(meta["train"]) != 149 or len(meta["validation"]) != 0:\n'
+     '        raise ValueError("Require reviewed all-149 training partition")\n',
+     '    if train_split_mode != "first_100" or list(meta["train"]) != list(range(100)):\n'
+     '        raise ValueError("Require the fixed first-100 training partition (episodes 0-99)")\n', 1),
+    ('"all_149"', '"first_100"', 7),
+    ('if not np.allclose(columns["timestamp"], np.arange(n) / 30.0, rtol=0, atol=3e-6):',
+     'if not np.allclose(columns["timestamp"], np.arange(n) / 30.0, rtol=1e-7, atol=3e-6):  # float32 timestamps of long (75 s) C6 episodes', 1),
+]
+
+
+def sha(path):
+    digest = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(16 << 20), b''):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def dump(path, value):
+    Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
+
+
+def log(*args):
+    print(time.strftime('%H:%M:%S'), *args, flush=True)
+
+
+def augmentation_config():
+    return dict(
+        version=AUG_VERSION, enabled=True, seed=20261110, spec='project CLAUDE.md augmentation default spec v2 (2026-11-09)',
+        implementation='imagewam/datasets/hb_aug_v2.py = unchanged copy of $G/hb_groot/hb_aug_v2.py',
+        implementation_sha256=AUG_SHA256, boost='one of 15 effects uniformly per sample, magnitude x1.5',
+        colour='exposure/contrast/saturation/hue/gamma/temperature shared by both cameras and both times',
+        per_camera='rotation+crop, light/shadow patches, single-channel white balance; same on t and t+16',
+        observation_only='noise, gaussian blur, JPEG, motion blur, sharpen, defocus (never on the t+16 target)',
+        native_model_image_augmentation='none', action_label_noise=False, state_label_noise=False)
+
+
+def build_code():
+    record = CODE / 'deltaflow-code.json'
+    if record.is_file():
+        for rel, digest in json.loads(record.read_text())['sha256'].items():
+            if sha(CODE / rel) != digest:
+                raise SystemExit(f'{CODE / rel} changed after preparation; rename {CODE} aside and rerun')
+        log('code copy present and unchanged:', CODE)
+        return
+    if CODE.exists():
+        raise SystemExit(f'{CODE} exists without deltaflow-code.json (incomplete); rename it aside and rerun')
+    for rel, digest in SOURCE_SHA256.items():
+        if sha(SRC_CODE / rel) != digest:
+            raise SystemExit(f'Source code differs from the reviewed copy: {SRC_CODE / rel}')
+    if sha(AUG_SRC) != AUG_SHA256:
+        raise SystemExit(f'{AUG_SRC} differs from the reviewed hb_aug_v2 ({AUG_SHA256[:12]})')
+    if sha(REF_DELTA) != REF_DELTA_SHA256:
+        raise SystemExit(f'{REF_DELTA} differs from the reviewed state44 reference ({REF_DELTA_SHA256[:12]})')
+    ROOT.mkdir(parents=True, exist_ok=True)
+    tmp = ROOT / f'.HumanWAM.tmp{os.getpid()}'
+    shutil.copytree(SRC_CODE, tmp, symlinks=True, ignore=shutil.ignore_patterns('__pycache__', '*.pyc'))
+    loader = tmp / 'src/imagewam/datasets/wholebody.py'
+    text = loader.read_text(encoding='utf-8')
+    for old, new, count in LOADER_PATCHES:
+        if text.count(old) != count:
+            raise SystemExit(f'Loader patch anchor found {text.count(old)}x (want {count}): {old[:60]!r}')
+        text = text.replace(old, new)
+    if '149' in text:
+        raise SystemExit('Loader still mentions 149 after patching')
+    loader.write_text(text, encoding='utf-8')
+    added = {'src/imagewam/datasets/hb_aug_v2.py': AUG_SRC,
+             'src/imagewam/datasets/wholebody_hbaug.py': H / 'wholebody_hbaug.py',
+             'scripts/wholebody/train_deltaflow.py': H / 'train_deltaflow.py',
+             'src/imagewam/wholebody_delta.py': REF_DELTA}
+    for rel, source in added.items():
+        shutil.copyfile(source, tmp / rel)
+    files = ['src/imagewam/datasets/wholebody.py', *added, *[k for k in SOURCE_SHA256 if k != 'src/imagewam/datasets/wholebody.py']]
+    dump(tmp / 'deltaflow-code.json', dict(
+        source=str(SRC_CODE), hb_aug_v2_source=str(AUG_SRC), created=time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+        changes=['wholebody.py: train exactly episodes 0-99 ("first_100"), later episodes shelved',
+                 'hb_aug_v2.py: unchanged copy of the shared spec-v2 implementation',
+                 'wholebody_hbaug.py: WholeBodyHBAugV2LeRobotDataset(WholeBodyRobustLeRobotDataset), visual aug -> '
+                 'hb_aug_v2, 44-D proprio, NO joint velocity (wholebody_velocity.py stays in the tree, unused); '
+                 'proprio aligned with GR00T A20 (per-sample perturb_joints, no delay, no history drop; 2026-11-12)',
+                 'train_deltaflow.py: 40-epoch entry, full state at every save, --resume',
+                 'wholebody_delta.py: the state44 copy of real30-from-sim60-20261108 (the B6 60-epoch copy hard-codes '
+                 'the 73-D velocity state)'],
+        sha256={rel: sha(tmp / rel) for rel in files}))
+    tmp.rename(CODE)
+    log('code copy built:', CODE)
+
+
+PROPRIO_DIM = 44   # body 29 + hands 12 + gravity 3 (NO velocity)
+
+
+def no_velocity(cfg, where):
+    """Reject any joint-velocity remnant in a training config (user rule 2026-11-10)."""
+    def walk(value, path):
+        if isinstance(value, dict):
+            for key, item in value.items():
+                if 'velocity' in str(key).lower() and item not in ([], None, False, 0):
+                    raise SystemExit(f'{where}: velocity setting left in the config: {path}.{key}={item!r}')
+                walk(item, f'{path}.{key}')
+        elif isinstance(value, list):
+            for i, item in enumerate(value):
+                walk(item, f'{path}[{i}]')
+        elif isinstance(value, str) and 'velocity' in value.lower() and 'no velocity' not in value.lower():
+            raise SystemExit(f'{where}: velocity reference left in the config: {path}={value!r}')
+    walk(cfg, 'cfg')
+
+
+def prepare_task(task, wb):
+    spec = TASKS[task]
+    R = ROOT / task
+    if (R / 'prepared.ok').is_file():
+        log(task, 'already prepared, skipping')
+        return
+    if R.exists():
+        aside = ROOT / f'{task}.incomplete-{time.strftime("%Y%m%dT%H%M%S")}'
+        R.rename(aside)
+        log(task, 'half-prepared directory moved to', aside)
+    D, old = spec['data'], spec['old']
+    (R / 'run').mkdir(parents=True)
+    log(task, 'dataset', D)
+
+    meta = wb.load_metadata(D)
+    ids = [int(e['episode_index']) for e in meta['episodes']]
+    lengths = {int(e['episode_index']): int(e['length']) for e in meta['episodes']}
+    train = list(range(EPISODES))
+    if ((spec['total_episodes'] is not None and len(ids) != spec['total_episodes']) or len(ids) < EPISODES
+            or ids[:EPISODES] != train):
+        raise SystemExit(f'{task}: expected {spec["total_episodes"]} episodes 0..N-1, found {len(ids)}')
+    shelved = ids[EPISODES:]
+    if old is None:
+        old_manifest = new_manifest(task, spec, meta, ids)
+    else:
+        old_manifest = json.loads((old / 'split-manifest.json').read_text())
+        if sorted(old_manifest['train_episode_ids'] + old_manifest['validation_episode_ids']) != ids:
+            raise SystemExit(f'{task}: previous split manifest does not cover this dataset')
+    basis = ('Fixed first 100 episodes (episode_index 0-99) per project rule 2026-11-09; '
+             + (f'episodes {shelved[0]}-{shelved[-1]} are shelved (listed as validation ids, never trained, '
+                'no validation run)' if shelved else 'the collection has exactly 100 episodes'))
+    manifest = dict(old_manifest, train_episode_ids=train, validation_episode_ids=shelved, shelved_episode_ids=shelved,
+                    split_basis=basis,
+                    previous_manifest=(str(old / 'split-manifest.json') if old is not None else 'none (generated)'))
+    dump(R / 'split-manifest.json', manifest)
+    wb.apply_split(meta, str(R / 'split-manifest.json'))     # provenance hashes, joint names, groups
+
+    log(task, 'fitting normalization statistics on episodes 0-99')
+    wb.prepare_statistics(str(D), str(R / 'stats'), train_split_mode='first_100',
+                          split_manifest_path=str(R / 'split-manifest.json'))
+    stats = json.loads((R / 'stats/dataset_stats.json').read_text())
+    frames = sum(lengths[i] for i in train)
+    if (stats['train_episode_ids'] != train or stats['heldout_episode_ids'] != shelved
+            or stats['train_frames'] != frames or stats['schema'] != wb.STATS_SCHEMA):
+        raise SystemExit(f'{task}: statistics do not cover exactly episodes 0-99')
+
+    u = math.ceil(frames / (WORLD * MICRO))
+    if u != math.ceil(math.ceil(frames / MICRO) / WORLD):
+        raise SystemExit('updates_per_epoch mismatch')
+    total, save_steps, warmup, n_epochs = fixed_schedule(u)
+
+    prompt = wb.DEFAULT_PROMPT.format(task=meta['tasks'][0]['task'])
+    qinfo = None
+    if old is not None:
+        shutil.copytree(old / 'qwen-text', R / 'qwen-text')
+    else:
+        import qwen_cache
+        ref_prompt = wb.DEFAULT_PROMPT.format(task=wb.load_metadata(TASKS['a3']['data'])['tasks'][0]['task'])
+        _, qinfo = qwen_cache.make(prompt, R / 'qwen-text', CODE, QWEN3, FLUX2_SRC, ref_prompt, TEMPLATE / 'qwen-text')
+        log(task, 'qwen cache computed', qinfo)
+    cache = R / 'qwen-text' / f'{hashlib.sha256(prompt.encode()).hexdigest()}.qwen3_flux2_len128.pt'
+    if not cache.is_file():
+        raise SystemExit(f'{task}: instruction cache missing in copied qwen-text: {cache.name}')
+
+    source_yaml = (old if old is not None else TEMPLATE) / 'run/production.yaml'
+    cfg = yaml.safe_load(source_yaml.read_text())
+    cfg.update(output_dir=str(R / 'run/production'), num_epochs=n_epochs, max_steps=total,
+               lr_scheduler_total_steps=total, warmup_steps=warmup, save_every=0, save_steps=save_steps,
+               save_at_end=True, keep_latest_weights=KEEP_CKPTS, keep_latest_state_only=True, resume=None, eval_every=0)
+    if cfg['batch_size'] != MICRO or cfg['gradient_accumulation_steps'] != 1 or cfg['data']['val'] is not None:
+        raise SystemExit(f'{task}: unexpected batch / accumulation / validation in {source_yaml}')
+    cfg['wandb'].update(enabled=False, mode='disabled', name=f'deltaflow-{task}-40ep-augv2-aligned')
+    d = cfg['data']['train']
+    d.update(_target_=DATASET_TARGET, dataset_dir=str(D), stats_path=str(R / 'stats/dataset_stats.json'),
+             qwen_text_cache_dir=str(R / 'qwen-text'), split_manifest_path=str(R / 'split-manifest.json'),
+             train_split_mode='first_100')
+    for key in [k for k in d if 'velocity' in k]:   # the previous run's 73-D loader keys (velocity_cache, noise)
+        del d[key]
+    d['image_augmentation'] = augmentation_config()
+    pa = d['proprio_augmentation']
+    pa.update(control_hz=spec['control_hz'], recording_hz=30, velocity_channels=[])
+    for key, value in dict(enabled=True, joint_bias_degrees=2.0, joint_noise_std_degrees=0.25, delay_probability=0.15,
+                           max_delay_control_cycles=2, history_drop_probability=0.15,
+                           affected_angle_channels=list(range(29)), bias_scope='fixed_per_episode').items():
+        if pa.get(key) != value:
+            raise SystemExit(f'{task}: proprio_augmentation.{key}={pa.get(key)!r} differs from spec v2 ({value!r})')
+    pa.update(ALIGNED_PROPRIO)
+    m = cfg['model']
+    if (m['proprio_dim'], m['action_state_dim'], m['expected_action_dim'], m['expected_action_horizon']) not in (
+            (73, 73, 76, 16), (44, 44, 76, 16)):
+        raise SystemExit(f'{task}: source model is not the 76-D action / horizon-16 Delta-flow')
+    m.update(proprio_dim=PROPRIO_DIM, action_state_dim=PROPRIO_DIM)   # = reference real30-from-sim60 (no velocity)
+    c = cfg['wholebody_contract']
+    for key in [k for k in c if 'velocity' in k]:
+        del c[key]
+    c.update(stats_schema=wb.STATS_SCHEMA, statistics_sha256=sha(R / 'stats/dataset_stats.json'),
+             smoke_output_dir=None, production_output_dir=str(R / 'run/production'), updates_per_epoch=u,
+             augmentation=AUG_VERSION, proprio_augmentation='aligned with GR00T A20 (per-sample perturb_joints, no delay, no history drop)', proprio_layout='body29 + hands12 + gravity3 = 44 (no velocity)',
+             train_episode_ids='0-99', shelved_episode_ids=(f'{shelved[0]}-{shelved[-1]}' if shelved else 'none'))
+    c['measured_loader'].update(dataset_frames=frames, raw_loader_batches=math.ceil(frames / MICRO),
+                                per_rank_microbatches=u, world_size=WORLD, microbatch=MICRO)
+    old = old if old is not None else TEMPLATE
+    old_prefix = str(old) + '/'
+
+    def walk(value):
+        if isinstance(value, dict):
+            for item in value.values():
+                walk(item)
+        elif isinstance(value, list):
+            for item in value:
+                walk(item)
+        elif isinstance(value, str) and (value.startswith(old_prefix) or value == str(old)):
+            raise SystemExit(f'{task}: config still points into the old experiment: {value}')
+    walk(cfg)
+    no_velocity(cfg, task)
+    c['source_config'] = str(source_yaml)
+    (R / 'run/production.yaml').write_text(yaml.safe_dump(cfg, sort_keys=False), encoding='utf-8')
+
+    dump(R / 'data-verified.json', dict(
+        task=task, dataset_dir=str(D), total_episodes_in_collection=len(ids), episodes=EPISODES,
+        train_episode_ids=train, shelved_episode_ids=shelved, frames=frames, updates_per_epoch=u, epochs=None, fixed_steps=True,
+        epochs_equivalent=round(total / u, 2),
+        max_steps=total, warmup_steps=warmup, save_steps=save_steps, control_hz=spec['control_hz'],
+        recording_hz=30, statistics_sha256=c['statistics_sha256'], proprio_dim=PROPRIO_DIM, joint_velocity=False,
+        augmentation=AUG_VERSION, proprio_augmentation=ALIGNED_PROPRIO, dataset_source=spec.get('source'),
+        qwen_cache=(qinfo or 'copied from the previous run'),
+        code=str(CODE), code_record_sha256=sha(CODE / 'deltaflow-code.json')))
+
+    log(task, 'loading two real augmented samples (CPU)')
+    from hydra.utils import instantiate
+    from omegaconf import OmegaConf
+    dataset = instantiate(OmegaConf.load(R / 'run/production.yaml').data.train)
+    if len(dataset) != frames or list(dataset.episode_ids) != train:
+        raise SystemExit(f'{task}: dataset length {len(dataset)} / episodes differ from {frames} / 0-99')
+    import torch
+    first, sample = dataset[0], dataset[min(20, len(dataset) - 1)]
+    if (tuple(first['video'].shape) != (3, 2, 224, 448) or tuple(first['proprio'].shape) != (16, PROPRIO_DIM)
+            or tuple(sample['proprio'].shape) != (16, PROPRIO_DIM) or tuple(sample['action'].shape) != (16, 76)
+            or not torch.isfinite(sample['proprio']).all() or dataset.last_augmentation['visual']['boost'] is None):
+        raise SystemExit(f'{task}: sample schema check failed')
+    perturb = []
+    for i in range(0, frames, max(1, frames // 40)):
+        dataset[i]
+        num = dataset.last_augmentation['numeric']
+        if num['delay_recorded_frames'] != 0 or num['history_drop_rows']:
+            raise SystemExit(f'{task}: delay / history drop still active: {num}')
+        perturb.append(num['joint_perturbation_degrees'])
+    perturb = np.asarray(perturb)
+    if perturb.shape[1] != 29 or np.abs(perturb).max() > 2.0 + 0.75 + 1e-3 or perturb.std(axis=0).min() < 0.5:
+        raise SystemExit(f'{task}: joint perturbation is not per-sample +-2 deg + 0.25 deg noise')
+    dump(R / 'prepared.ok', dict(frames=frames, updates_per_epoch=u, max_steps=total, save_steps=save_steps,
+                                 proprio_check=dict(samples=len(perturb), max_abs_deg=float(np.abs(perturb).max()),
+                                                    std_deg=float(perturb.std()))))
+    log(task, 'PREPARED', json.dumps(dict(frames=frames, updates_per_epoch=u, max_steps=total, save_steps=save_steps,
+                                          warmup=warmup, control_hz=spec['control_hz'])))
+
+
+def main():
+    tasks = sys.argv[1:] or [*TASKS, *H2_TASKS]
+    for task in tasks:
+        if task not in TASKS and task not in H2_TASKS:
+            raise SystemExit(f'unknown task {task}; choose from {[*TASKS, *H2_TASKS]}')
+    g1 = [task for task in tasks if task in TASKS]
+    if g1:
+        build_code()
+        sys.path.insert(0, str(CODE / 'src'))
+        os.environ.setdefault('HF_HUB_OFFLINE', '1')
+        import imagewam.datasets.wholebody as wb
+        if not wb.__file__.startswith(str(CODE / 'src')):
+            raise SystemExit(f'imported the wrong imagewam: {wb.__file__}')
+        for task in g1:
+            prepare_task(task, wb)
+    h2 = [task for task in tasks if task in H2_TASKS]
+    if h2:
+        # The H2 branch ships its own imagewam package: prepare it in a separate interpreter.
+        import subprocess
+        rc = subprocess.call([sys.executable, str(H / 'prepare_deltaflow_h2.py'), *h2])
+        if rc != 0:
+            raise SystemExit(f'H2 preparation failed (rc {rc})')
+    log('PREPARE_DONE', ' '.join(tasks))
+
+
+if __name__ == '__main__':
+    main()

code/hb_deltaflow/prepare_deltaflow_a18.py

@@ -0,0 +1,199 @@
+"""A18 (H2 pour water) preparation for the Delta-flow 40-epoch runs. CPU only, node 0, idempotent.
+
+    $P/venv/bin/python $G/hb_deltaflow/prepare_deltaflow_a18.py      (also called by prepare_deltaflow.py a18)
+NO joint velocity (user rule 2026-11-10): the model is the original 78-D H2 model of a18-h2-pour-from-scratch-20261108
+(imagewam/h2_pour_delta.py, unchanged; same as HF g1-basket-transfer-imagewam-deltaflow76 h2-a18-pour-water/epoch-040,
+proprio_dim 78 = 75 joints + gravity 3). No velocity cache or statistics are produced.
+Creates:
+    $G/deltaflow-runs/HumanWAM-h2/   copy of $P/a18-h2-pour-from-scratch-20261108/HumanWAM (hash-checked) plus
+        src/imagewam/datasets/hb_aug_v2.py   unchanged copy of $G/hb_groot/hb_aug_v2.py
+        src/imagewam/datasets/h2_hbaug.py    H2HBAugV2Dataset (aug v2 + 31-joint proprio aug, 78-D, no velocity)
+        scripts/wholebody/train_deltaflow.py the shared 40-epoch entry
+    $G/deltaflow-runs/a18/{stats/normalization.json, qwen-text/, run/production.yaml, data-verified.json, prepared.ok}
+"""
+import hashlib
+import inspect
+import json
+import math
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+import yaml
+
+import prepare_deltaflow as base
+
+H, G, P, ROOT = base.H, base.G, base.P, base.ROOT
+OLD = P / 'a18-h2-pour-from-scratch-20261108'
+SRC_CODE = OLD / 'HumanWAM'
+DATA = P / 'a18-h2-dataset-audit-8e956a10' / 'dataset'
+CODE = ROOT / 'HumanWAM-h2'
+R = ROOT / 'a18'
+EPISODES, FRAMES, BODY, STATE, ACTION = 100, 72752, 31, 78, 75
+DATASET_TARGET = 'imagewam.datasets.h2_hbaug.H2HBAugV2Dataset'
+SOURCE_SHA256 = {   # = h2-run-manifest.json file_sha256 / reviewed local copy
+    'src/imagewam/datasets/h2_pour.py': 'd61ec58b83c20621488899c023a348fed52a7881f8faa4f6ba277fcb9c399168',
+    'src/imagewam/h2_pour_delta.py': '69bf26169559b082a0a45152512497998163b63c69723d1af606dcf82eca47fc',
+    'src/imagewam/datasets/wholebody.py': '4d81de5a73109752128a41a65b01121afe12de15cac42f215157c4e30008ccf9',
+    'src/imagewam/trainer.py': 'cdcd48e09d1d7b81cae3a829bd415ed4b53ff1b290aacac1ce2217876f475b1a',
+    'src/imagewam/runtime.py': '3ebc45f61b0c22fb659012a7d76bea671a42e1e528b5c917ae1e8827e88b890b',
+    'scripts/wholebody/train_h2_pour.py': '69c6974418b9ed02cae4c9cca7177e3c32a213d9cc833ecd3d0c95489d901a5e',
+    'scripts/accelerate_configs/accelerate_zero1_ds.yaml': '5b9e24f38c199fdff6bbd17981d86e2624f855f707660094c99f711efc8e0833',
+}
+sha, dump, log = base.sha, base.dump, base.log
+
+
+def build_code():
+    record = CODE / 'deltaflow-code.json'
+    if record.is_file():
+        for rel, digest in json.loads(record.read_text())['sha256'].items():
+            if sha(CODE / rel) != digest:
+                raise SystemExit(f'{CODE / rel} changed after preparation; rename {CODE} aside and rerun')
+        log('H2 code copy present and unchanged:', CODE)
+        return
+    if CODE.exists():
+        raise SystemExit(f'{CODE} exists without deltaflow-code.json (incomplete); rename it aside and rerun')
+    for rel, digest in SOURCE_SHA256.items():
+        if sha(SRC_CODE / rel) != digest:
+            raise SystemExit(f'H2 source differs from the reviewed copy: {SRC_CODE / rel}')
+    if sha(base.AUG_SRC) != base.AUG_SHA256:
+        raise SystemExit(f'{base.AUG_SRC} differs from the reviewed hb_aug_v2')
+    ROOT.mkdir(parents=True, exist_ok=True)
+    tmp = ROOT / f'.HumanWAM-h2.tmp{os.getpid()}'
+    shutil.copytree(SRC_CODE, tmp, symlinks=True, ignore=shutil.ignore_patterns('__pycache__', '*.pyc'))
+    added = {'src/imagewam/datasets/hb_aug_v2.py': base.AUG_SRC,
+             'src/imagewam/datasets/h2_hbaug.py': H / 'h2_hbaug.py',
+             'scripts/wholebody/train_deltaflow.py': H / 'train_deltaflow.py'}
+    for rel, source in added.items():
+        shutil.copyfile(source, tmp / rel)
+    files = [*added, *SOURCE_SHA256]
+    dump(tmp / 'deltaflow-code.json', dict(
+        source=str(SRC_CODE), hb_aug_v2_source=str(base.AUG_SRC),
+        created=time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+        changes=['h2_pour_delta.py: unchanged original 78-D H2 model (no joint velocity)',
+                 'hb_aug_v2.py: unchanged copy of the shared spec-v2 implementation',
+                 'h2_hbaug.py: H2HBAugV2Dataset (aug v2 + 31-joint proprio aug, 78-D state, no velocity)',
+                 'train_deltaflow.py: shared 40-epoch entry, full state at every save, --resume'],
+        sha256={rel: sha(tmp / rel) for rel in files}))
+    tmp.rename(CODE)
+    log('H2 code copy built:', CODE)
+
+
+def prepare():
+    if (R / 'prepared.ok').is_file():
+        log('a18 already prepared, skipping')
+        return
+    if R.exists():
+        aside = ROOT / f'a18.incomplete-{time.strftime("%Y%m%dT%H%M%S")}'
+        R.rename(aside)
+        log('a18 half-prepared directory moved to', aside)
+    (R / 'run').mkdir(parents=True)
+    (R / 'stats').mkdir()
+    sys.path.insert(0, str(CODE / 'src'))
+    os.environ.setdefault('HF_HUB_OFFLINE', '1')
+    from imagewam.datasets import h2_pour
+    if not h2_pour.__file__.startswith(str(CODE / 'src')):
+        raise SystemExit(f'imported the wrong imagewam: {h2_pour.__file__}')
+    if h2_pour.STATE_DIM != STATE or h2_pour.ACTION_DIM != ACTION:
+        raise SystemExit(f'h2_pour dims {h2_pour.STATE_DIM}/{h2_pour.ACTION_DIM}, expected {STATE}/{ACTION}')
+    episodes, instruction, names = h2_pour.load_collection(DATA)   # exactly 100 episodes / 72752 frames
+    lengths = [int(e['length']) for e in episodes]
+    if [e['episode_index'] for e in episodes] != list(range(EPISODES)) or sum(lengths) != FRAMES:
+        raise SystemExit('A18 collection is not episodes 0-99 / 72752 frames')
+    if list(h2_pour.CAMERAS) != ['observation.images.head', 'observation.images.chest']:
+        raise SystemExit(f'Unexpected H2 cameras {h2_pour.CAMERAS}')
+
+    log('a18 normalization (q01/q99 of state78 / action75 over episodes 0-99)')
+    h2_pour.fit(DATA, R / 'stats/normalization.json')
+
+    u = math.ceil(FRAMES / (base.WORLD * base.MICRO))              # 285
+    total = base.EPOCHS * u
+    save_steps = [e * u for e in range(base.SAVE_EVERY_EPOCHS, base.EPOCHS + 1, base.SAVE_EVERY_EPOCHS)]
+    shutil.copytree(OLD / 'qwen-text', R / 'qwen-text')
+    prompt = h2_pour.DEFAULT_PROMPT.format(task=instruction)
+    cache = R / 'qwen-text' / f'{hashlib.sha256(prompt.encode()).hexdigest()}.qwen3_flux2_len128.pt'
+    if not cache.is_file():
+        raise SystemExit(f'a18: instruction cache missing in copied qwen-text: {cache.name}')
+
+    source_yaml = OLD / 'run/production.yaml'
+    cfg = yaml.safe_load(source_yaml.read_text())
+    cfg.update(output_dir=str(R / 'run/production'), num_epochs=base.EPOCHS, max_steps=total,
+               lr_scheduler_total_steps=total, warmup_steps=base.WARMUP_EPOCHS * u, save_every=0,
+               save_steps=save_steps, save_at_end=True, keep_latest_weights=4, keep_latest_state_only=True,
+               resume=None, eval_every=0)
+    if cfg['batch_size'] != base.MICRO or cfg['gradient_accumulation_steps'] != 1 or cfg['data']['val'] is not None:
+        raise SystemExit('a18: unexpected batch / accumulation / validation in the H2 config')
+    cfg['wandb'].update(enabled=False, mode='disabled', name='deltaflow-a18-40ep-augv2', group='h2-action75-state78')
+    old_train = cfg['data']['train']
+    cfg['data']['train'] = dict(
+        _target_=DATASET_TARGET, dataset_dir=str(DATA), stats_path=str(R / 'stats/normalization.json'),
+        qwen_text_cache_dir=str(R / 'qwen-text'), qwen_context_len=old_train['qwen_context_len'],
+        qwen_text_dim=old_train['qwen_text_dim'], video_cache_frames=64,
+        image_augmentation=base.augmentation_config(),
+        proprio_augmentation=dict(
+            enabled=True, seed=20261106, joint_bias_degrees=2.0, joint_noise_std_degrees=0.25, delay_probability=0.15,
+            max_delay_control_cycles=2, control_hz=30, recording_hz=30, history_drop_probability=0.15,
+            affected_angle_channels=list(range(BODY)), velocity_channels=[],
+            action_label_noise=False, bias_scope='fixed_per_episode', body_joints='observation.state[0:31] incl. head',
+            start_pose_library='not_applied_offline', render_randomization='not_applied_offline'))
+    m = cfg['model']
+    if (m['expected_action_dim'], m['action_dit_config']['action_dim'], len(m['loss']['action_a2a']['source_noise_dim_mask']),
+            m['proprio_dim'], m['action_state_dim'], m['expected_action_horizon']) != (ACTION, ACTION, ACTION, STATE, STATE, 16):
+        raise SystemExit('a18: the H2 config is not the 78-D state / 75-D action Delta-flow it should be')
+    if 'h2_pour_delta' not in str(m.get('_target_', '')):
+        raise SystemExit(f"a18: unexpected model target {m.get('_target_')!r} (want the original h2_pour_delta)")
+    cfg['wholebody_contract'] = dict(
+        task='a18', robot='h2_sharpa', world_size=base.WORLD, zero_stage=1, fresh_base=True,
+        production_output_dir=str(R / 'run/production'), updates_per_epoch=u, train_episode_ids='0-99',
+        statistics_sha256=sha(R / 'stats/normalization.json'), augmentation=base.AUG_VERSION,
+        state_layout='joints75 + gravity3 = 78 (no velocity)',
+        action_layout='body_target31 + hands44 = 75', cameras=list(h2_pour.CAMERAS),
+        measured_loader=dict(dataset_frames=FRAMES, raw_loader_batches=math.ceil(FRAMES / base.MICRO),
+                             per_rank_microbatches=u, world_size=base.WORLD, microbatch=base.MICRO,
+                             gradient_accumulation=1),
+        source_config=str(source_yaml))
+    for value in (cfg['output_dir'], cfg['data']['train']['stats_path'], cfg['data']['train']['qwen_text_cache_dir']):
+        if value.startswith(str(OLD) + '/'):
+            raise SystemExit(f'a18: config still points into the old experiment: {value}')
+    base.no_velocity(cfg, 'a18')
+    (R / 'run/production.yaml').write_text(yaml.safe_dump(cfg, sort_keys=False), encoding='utf-8')
+    previous = OLD / 'normalization.json'
+    dump(R / 'data-verified.json', dict(
+        task='a18', dataset_dir=str(DATA), total_episodes_in_collection=EPISODES, episodes=EPISODES,
+        train_episode_ids=list(range(EPISODES)), shelved_episode_ids=[], frames=FRAMES, updates_per_epoch=u,
+        epochs=base.EPOCHS, max_steps=total, warmup_steps=base.WARMUP_EPOCHS * u, save_steps=save_steps,
+        control_hz=30, recording_hz=30, statistics_sha256=sha(R / 'stats/normalization.json'),
+        statistics_equal_previous_a18_run=previous.is_file() and sha(previous) == sha(R / 'stats/normalization.json'),
+        augmentation=base.AUG_VERSION, state_dim=STATE, action_dim=ACTION, joint_velocity=False,
+        code=str(CODE), code_record_sha256=sha(CODE / 'deltaflow-code.json')))
+
+    log('a18 model module check (no weights loaded)')
+    import imagewam.h2_pour_delta as model_module
+    factory = inspect.signature(model_module.create_imagewam_flux2_wholebody_delta)
+    if (factory.parameters['action_state_dim'].default != STATE
+            or factory.parameters['expected_action_dim'].default != ACTION):
+        raise SystemExit('a18: original H2 model module is not 78-D state / 75-D action')
+
+    log('a18 loading two real augmented samples (CPU)')
+    import torch
+    from hydra.utils import instantiate
+    from omegaconf import OmegaConf
+    dataset = instantiate(OmegaConf.load(R / 'run/production.yaml').data.train)
+    if len(dataset) != FRAMES or list(dataset.episode_ids) != list(range(EPISODES)):
+        raise SystemExit(f'a18: dataset length {len(dataset)} differs from {FRAMES}')
+    first, sample = dataset[0], dataset[145]
+    if (tuple(first['video'].shape) != (3, 2, 224, 448) or tuple(first['proprio'].shape) != (16, STATE)
+            or tuple(sample['proprio'].shape) != (16, STATE) or tuple(sample['proprio_dim_is_pad'].shape) != (STATE,)
+            or tuple(sample['action'].shape) != (16, ACTION) or tuple(sample['past_action'].shape) != (16, ACTION)
+            or not torch.isfinite(sample['proprio']).all() or dataset.last_augmentation['visual']['boost'] is None):
+        raise SystemExit('a18: sample schema check failed')
+    dump(R / 'prepared.ok', dict(frames=FRAMES, updates_per_epoch=u, max_steps=total, save_steps=save_steps))
+    log('a18 PREPARED', json.dumps(dict(frames=FRAMES, updates_per_epoch=u, max_steps=total, save_steps=save_steps,
+                                        warmup=base.WARMUP_EPOCHS * u, state_dim=STATE, action_dim=ACTION)))
+
+
+if __name__ == '__main__':
+    build_code()
+    prepare()

code/hb_deltaflow/prepare_deltaflow_h2.py

@@ -0,0 +1,251 @@
+"""H2 (A18 pour water, A17 unscrew bottle) preparation for the Delta-flow 40-epoch runs. CPU only, node 0, idempotent.
+
+    $P/venv/bin/python $G/hb_deltaflow/prepare_deltaflow_h2.py <a18|a17>   (also called by prepare_deltaflow.py)
+Generalizes prepare_deltaflow_a18.py (2026-11-12): proprio aligned with GR00T's A20 recipe (per-sample
+hb_aug_v2.perturb_joints on the 31 H2 body joints, no delay, no history drop) and A17 added.
+NO joint velocity (user rule 2026-11-10): the model is the original 78-D H2 model of a18-h2-pour-from-scratch-20261108
+(imagewam/h2_pour_delta.py, unchanged; proprio_dim 78 = 75 joints + gravity 3).
+Creates:
+    $G/deltaflow-runs/HumanWAM-h2/   copy of $P/a18-h2-pour-from-scratch-20261108/HumanWAM (hash-checked) plus
+        src/imagewam/datasets/hb_aug_v2.py   unchanged copy of $G/hb_groot/hb_aug_v2.py
+        src/imagewam/datasets/h2_hbaug.py    H2HBAugV2Dataset (aug v2 + aligned 31-joint proprio aug, 78-D)
+        scripts/wholebody/train_deltaflow.py the shared 40-epoch entry
+        src/imagewam/datasets/h2_pour.py     frame total read from meta/info.json instead of the A18 constant 72752
+    $G/deltaflow-runs/<task>/{stats/normalization.json, qwen-text/, run/production.yaml, data-verified.json, prepared.ok}
+"""
+import hashlib
+import inspect
+import json
+import math
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+import yaml
+
+import prepare_deltaflow as base
+
+H, G, P, ROOT = base.H, base.G, base.P, base.ROOT
+OLD = P / 'a18-h2-pour-from-scratch-20261108'
+SRC_CODE = OLD / 'HumanWAM'
+CODE = ROOT / 'HumanWAM-h2'
+TASKS = {'a18': dict(data=P / 'a18-h2-dataset-audit-8e956a10' / 'dataset', frames=72752, qwen='copy',
+                     source='a18 H2 pour water (audited 8e956a10)'),
+         'a17': dict(data=P / 'a17-unscrew-bottle-v1-407e6e2' / 'data', frames=115333, qwen='compute',
+                     source='a17-unscrew-bottle-expert-v1 @407e6e2')}
+EPISODES, BODY, STATE, ACTION = 100, 31, 78, 75
+DATASET_TARGET = 'imagewam.datasets.h2_hbaug.H2HBAugV2Dataset'
+SOURCE_SHA256 = {   # = h2-run-manifest.json file_sha256 / reviewed local copy
+    'src/imagewam/datasets/h2_pour.py': 'd61ec58b83c20621488899c023a348fed52a7881f8faa4f6ba277fcb9c399168',
+    'src/imagewam/h2_pour_delta.py': '69bf26169559b082a0a45152512497998163b63c69723d1af606dcf82eca47fc',
+    'src/imagewam/datasets/wholebody.py': '4d81de5a73109752128a41a65b01121afe12de15cac42f215157c4e30008ccf9',
+    'src/imagewam/trainer.py': 'cdcd48e09d1d7b81cae3a829bd415ed4b53ff1b290aacac1ce2217876f475b1a',
+    'src/imagewam/runtime.py': '3ebc45f61b0c22fb659012a7d76bea671a42e1e528b5c917ae1e8827e88b890b',
+    'scripts/wholebody/train_h2_pour.py': '69c6974418b9ed02cae4c9cca7177e3c32a213d9cc833ecd3d0c95489d901a5e',
+    'scripts/accelerate_configs/accelerate_zero1_ds.yaml': '5b9e24f38c199fdff6bbd17981d86e2624f855f707660094c99f711efc8e0833',
+}
+H2_POUR_PATCHES = [  # make the A18-specific frame total generic (A17 has 115333 frames); everything else unchanged
+    ("sum(row['length'] for row in episodes)!=72752", "sum(row['length'] for row in episodes)!=int(info['total_frames'])"),
+    ("frames=72752,", "frames=sum(int(row['length']) for row in episodes),"),
+]
+ALIGNED = dict(delay_probability=0.0, max_delay_control_cycles=0, history_drop_probability=0.0,
+               bias_scope='per_sample', implementation='hb_aug_v2.perturb_joints',
+               aligned_with='GR00T A20 basket-transfer recipe (hb_groot/hb_launch.py), user 2026-11-12')
+sha, dump, log = base.sha, base.dump, base.log
+
+
+def build_code():
+    record = CODE / 'deltaflow-code.json'
+    if record.is_file():
+        for rel, digest in json.loads(record.read_text())['sha256'].items():
+            if sha(CODE / rel) != digest:
+                raise SystemExit(f'{CODE / rel} changed after preparation; rename {CODE} aside and rerun')
+        log('H2 code copy present and unchanged:', CODE)
+        return
+    if CODE.exists():
+        raise SystemExit(f'{CODE} exists without deltaflow-code.json (incomplete); rename it aside and rerun')
+    for rel, digest in SOURCE_SHA256.items():
+        if sha(SRC_CODE / rel) != digest:
+            raise SystemExit(f'H2 source differs from the reviewed copy: {SRC_CODE / rel}')
+    if sha(base.AUG_SRC) != base.AUG_SHA256:
+        raise SystemExit(f'{base.AUG_SRC} differs from the reviewed hb_aug_v2')
+    ROOT.mkdir(parents=True, exist_ok=True)
+    tmp = ROOT / f'.HumanWAM-h2.tmp{os.getpid()}'
+    shutil.copytree(SRC_CODE, tmp, symlinks=True, ignore=shutil.ignore_patterns('__pycache__', '*.pyc'))
+    added = {'src/imagewam/datasets/hb_aug_v2.py': base.AUG_SRC,
+             'src/imagewam/datasets/h2_hbaug.py': H / 'h2_hbaug.py',
+             'scripts/wholebody/train_deltaflow.py': H / 'train_deltaflow.py'}
+    for rel, source in added.items():
+        shutil.copyfile(source, tmp / rel)
+    pour = tmp / 'src/imagewam/datasets/h2_pour.py'
+    text = pour.read_text(encoding='utf-8')
+    for old, new in H2_POUR_PATCHES:
+        if text.count(old) != 1:
+            raise SystemExit(f'h2_pour patch anchor found {text.count(old)}x: {old!r}')
+        text = text.replace(old, new)
+    pour.write_text(text, encoding='utf-8')
+    files = [*added, *SOURCE_SHA256]
+    dump(tmp / 'deltaflow-code.json', dict(
+        source=str(SRC_CODE), hb_aug_v2_source=str(base.AUG_SRC),
+        created=time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+        changes=['h2_pour_delta.py: unchanged original 78-D H2 model (no joint velocity)',
+                 'hb_aug_v2.py: unchanged copy of the shared spec-v2 implementation',
+                 'h2_hbaug.py: H2HBAugV2Dataset (aug v2 + 31-joint proprio aug aligned with GR00T A20: per-sample '
+                 'perturb_joints, no delay, no history drop; 78-D state, no velocity)',
+                 'h2_pour.py: total frame count read from meta/info.json (was the A18 constant 72752) so A17 loads',
+                 'train_deltaflow.py: shared 40-epoch entry, full state at every save, --resume'],
+        sha256={rel: sha(tmp / rel) for rel in files}))
+    tmp.rename(CODE)
+    log('H2 code copy built:', CODE)
+
+
+def prepare(task):
+    spec = TASKS[task]
+    DATA, FRAMES = spec['data'], spec['frames']
+    R = ROOT / task
+    if (R / 'prepared.ok').is_file():
+        log(task, 'already prepared, skipping')
+        return
+    if R.exists():
+        aside = ROOT / f'{task}.incomplete-{time.strftime("%Y%m%dT%H%M%S")}'
+        R.rename(aside)
+        log(task, 'half-prepared directory moved to', aside)
+    (R / 'run').mkdir(parents=True)
+    (R / 'stats').mkdir()
+    sys.path.insert(0, str(CODE / 'src'))
+    os.environ.setdefault('HF_HUB_OFFLINE', '1')
+    from imagewam.datasets import h2_pour
+    if not h2_pour.__file__.startswith(str(CODE / 'src')):
+        raise SystemExit(f'imported the wrong imagewam: {h2_pour.__file__}')
+    if h2_pour.STATE_DIM != STATE or h2_pour.ACTION_DIM != ACTION:
+        raise SystemExit(f'h2_pour dims {h2_pour.STATE_DIM}/{h2_pour.ACTION_DIM}, expected {STATE}/{ACTION}')
+    episodes, instruction, names = h2_pour.load_collection(DATA)
+    lengths = [int(e['length']) for e in episodes]
+    if [e['episode_index'] for e in episodes] != list(range(EPISODES)) or sum(lengths) != FRAMES:
+        raise SystemExit(f'{task} collection is not episodes 0-99 / {FRAMES} frames')
+    if list(h2_pour.CAMERAS) != ['observation.images.head', 'observation.images.chest']:
+        raise SystemExit(f'Unexpected H2 cameras {h2_pour.CAMERAS}')
+
+    log(task, 'normalization (q01/q99 of state78 / action75 over episodes 0-99)')
+    h2_pour.fit(DATA, R / 'stats/normalization.json')
+
+    u = math.ceil(FRAMES / (base.WORLD * base.MICRO))
+    total, save_steps, warmup, n_epochs = base.fixed_schedule(u)
+    prompt = h2_pour.DEFAULT_PROMPT.format(task=instruction)
+    qinfo = None
+    if spec['qwen'] == 'copy':
+        shutil.copytree(OLD / 'qwen-text', R / 'qwen-text')
+    else:
+        import qwen_cache
+        ref_episodes, ref_instruction, _ = h2_pour.load_collection(TASKS['a18']['data'])
+        _, qinfo = qwen_cache.make(prompt, R / 'qwen-text', CODE, base.QWEN3, base.FLUX2_SRC,
+                                   h2_pour.DEFAULT_PROMPT.format(task=ref_instruction), OLD / 'qwen-text')
+        log(task, 'qwen cache computed', qinfo)
+    cache = R / 'qwen-text' / f'{hashlib.sha256(prompt.encode()).hexdigest()}.qwen3_flux2_len128.pt'
+    if not cache.is_file():
+        raise SystemExit(f'{task}: instruction cache missing: {cache.name}')
+
+    source_yaml = OLD / 'run/production.yaml'
+    cfg = yaml.safe_load(source_yaml.read_text())
+    cfg.update(output_dir=str(R / 'run/production'), num_epochs=n_epochs, max_steps=total,
+               lr_scheduler_total_steps=total, warmup_steps=warmup, save_every=0,
+               save_steps=save_steps, save_at_end=True, keep_latest_weights=base.KEEP_CKPTS, keep_latest_state_only=True,
+               resume=None, eval_every=0)
+    if cfg['batch_size'] != base.MICRO or cfg['gradient_accumulation_steps'] != 1 or cfg['data']['val'] is not None:
+        raise SystemExit(f'{task}: unexpected batch / accumulation / validation in the H2 config')
+    cfg['wandb'].update(enabled=False, mode='disabled', name=f'deltaflow-{task}-40ep-augv2-aligned',
+                        group='h2-action75-state78')
+    old_train = cfg['data']['train']
+    cfg['data']['train'] = dict(
+        _target_=DATASET_TARGET, dataset_dir=str(DATA), stats_path=str(R / 'stats/normalization.json'),
+        qwen_text_cache_dir=str(R / 'qwen-text'), qwen_context_len=old_train['qwen_context_len'],
+        qwen_text_dim=old_train['qwen_text_dim'], video_cache_frames=64,
+        image_augmentation=base.augmentation_config(),
+        proprio_augmentation=dict(
+            enabled=True, seed=20261106, joint_bias_degrees=2.0, joint_noise_std_degrees=0.25, control_hz=30,
+            recording_hz=30, affected_angle_channels=list(range(BODY)), velocity_channels=[],
+            action_label_noise=False, body_joints='observation.state[0:31] incl. head',
+            start_pose_library='not_applied_offline', render_randomization='not_applied_offline', **ALIGNED))
+    m = cfg['model']
+    if (m['expected_action_dim'], m['action_dit_config']['action_dim'], len(m['loss']['action_a2a']['source_noise_dim_mask']),
+            m['proprio_dim'], m['action_state_dim'], m['expected_action_horizon']) != (ACTION, ACTION, ACTION, STATE, STATE, 16):
+        raise SystemExit(f'{task}: the H2 config is not the 78-D state / 75-D action Delta-flow it should be')
+    if 'h2_pour_delta' not in str(m.get('_target_', '')):
+        raise SystemExit(f"{task}: unexpected model target {m.get('_target_')!r} (want the original h2_pour_delta)")
+    cfg['wholebody_contract'] = dict(
+        task=task, robot='h2_sharpa', world_size=base.WORLD, zero_stage=1, fresh_base=True,
+        production_output_dir=str(R / 'run/production'), updates_per_epoch=u, train_episode_ids='0-99',
+        statistics_sha256=sha(R / 'stats/normalization.json'), augmentation=base.AUG_VERSION,
+        proprio_augmentation='aligned with GR00T A20 (per-sample perturb_joints, no delay, no history drop)',
+        state_layout='joints75 + gravity3 = 78 (no velocity)',
+        action_layout='body_target31 + hands44 = 75', cameras=list(h2_pour.CAMERAS),
+        measured_loader=dict(dataset_frames=FRAMES, raw_loader_batches=math.ceil(FRAMES / base.MICRO),
+                             per_rank_microbatches=u, world_size=base.WORLD, microbatch=base.MICRO,
+                             gradient_accumulation=1),
+        source_config=str(source_yaml))
+    for value in (cfg['output_dir'], cfg['data']['train']['stats_path'], cfg['data']['train']['qwen_text_cache_dir']):
+        if value.startswith(str(OLD) + '/'):
+            raise SystemExit(f'{task}: config still points into the old experiment: {value}')
+    base.no_velocity(cfg, task)
+    (R / 'run/production.yaml').write_text(yaml.safe_dump(cfg, sort_keys=False), encoding='utf-8')
+    previous = OLD / 'normalization.json'
+    dump(R / 'data-verified.json', dict(
+        task=task, dataset_dir=str(DATA), dataset_source=spec['source'], total_episodes_in_collection=EPISODES,
+        episodes=EPISODES, train_episode_ids=list(range(EPISODES)), shelved_episode_ids=[], frames=FRAMES,
+        updates_per_epoch=u, epochs=None, fixed_steps=True,
+        epochs_equivalent=round(total / u, 2), max_steps=total, warmup_steps=warmup,
+        save_steps=save_steps, control_hz=30, recording_hz=30, statistics_sha256=sha(R / 'stats/normalization.json'),
+        statistics_equal_previous_a18_run=(task == 'a18' and previous.is_file()
+                                           and sha(previous) == sha(R / 'stats/normalization.json')),
+        augmentation=base.AUG_VERSION, proprio_augmentation=ALIGNED, qwen_cache=(qinfo or 'copied from the A18 run'),
+        state_dim=STATE, action_dim=ACTION, joint_velocity=False,
+        code=str(CODE), code_record_sha256=sha(CODE / 'deltaflow-code.json')))
+
+    log(task, 'model module check (no weights loaded)')
+    import imagewam.h2_pour_delta as model_module
+    factory = inspect.signature(model_module.create_imagewam_flux2_wholebody_delta)
+    if (factory.parameters['action_state_dim'].default != STATE
+            or factory.parameters['expected_action_dim'].default != ACTION):
+        raise SystemExit(f'{task}: original H2 model module is not 78-D state / 75-D action')
+
+    log(task, 'loading real augmented samples (CPU)')
+    import numpy as np
+    import torch
+    from hydra.utils import instantiate
+    from omegaconf import OmegaConf
+    dataset = instantiate(OmegaConf.load(R / 'run/production.yaml').data.train)
+    if len(dataset) != FRAMES or list(dataset.episode_ids) != list(range(EPISODES)):
+        raise SystemExit(f'{task}: dataset length {len(dataset)} differs from {FRAMES}')
+    first, sample = dataset[0], dataset[145]
+    if (tuple(first['video'].shape) != (3, 2, 224, 448) or tuple(first['proprio'].shape) != (16, STATE)
+            or tuple(sample['proprio'].shape) != (16, STATE) or tuple(sample['proprio_dim_is_pad'].shape) != (STATE,)
+            or tuple(sample['action'].shape) != (16, ACTION) or tuple(sample['past_action'].shape) != (16, ACTION)
+            or not torch.isfinite(sample['proprio']).all() or dataset.last_augmentation['visual']['boost'] is None):
+        raise SystemExit(f'{task}: sample schema check failed')
+    perturb = []
+    for i in range(0, FRAMES, max(1, FRAMES // 40)):
+        dataset[i]
+        num = dataset.last_augmentation['numeric']
+        if num['delay_recorded_frames'] != 0 or num['history_drop_rows'] or num['state_frame'] != num['anchor_frame']:
+            raise SystemExit(f'{task}: delay / history drop still active: {num}')
+        perturb.append(num['joint_perturbation_degrees'])
+    perturb = np.asarray(perturb)
+    if perturb.shape[1] != BODY or np.abs(perturb).max() > 2.0 + 0.75 + 1e-3 or perturb.std(axis=0).min() < 0.5:
+        raise SystemExit(f'{task}: joint perturbation is not per-sample +-2 deg + 0.25 deg noise')
+    dump(R / 'prepared.ok', dict(frames=FRAMES, updates_per_epoch=u, max_steps=total, save_steps=save_steps,
+                                 proprio_check=dict(samples=len(perturb), max_abs_deg=float(np.abs(perturb).max()),
+                                                    std_deg=float(perturb.std()))))
+    log(task, 'PREPARED', json.dumps(dict(frames=FRAMES, updates_per_epoch=u, max_steps=total, save_steps=save_steps,
+                                          warmup=warmup, state_dim=STATE, action_dim=ACTION)))
+
+
+if __name__ == '__main__':
+    tasks = sys.argv[1:] or list(TASKS)
+    for t in tasks:
+        if t not in TASKS:
+            raise SystemExit(f'unknown H2 task {t}; choose from {list(TASKS)}')
+    build_code()
+    for t in tasks:
+        prepare(t)

code/hb_deltaflow/qwen_cache.py

@@ -0,0 +1,79 @@
+"""FLUX.2 Qwen3 instruction cache for Delta-flow tasks that have no previous experiment to copy it from.
+
+Same computation as HumanWAM scripts/flux2/precompute_flux2_qwen3_embeds.py (chat template, enable_thinking False,
+padding to max_length 128, hidden states of flux2.text_encoder.OUTPUT_LAYERS_QWEN3 concatenated, stored as bf16 +
+bool mask), on CPU in bfloat16 (the GPU original also runs the model in bfloat16). make() first recomputes a reference
+prompt whose cache already exists (A3) and refuses to write anything unless the result matches it.
+"""
+import hashlib
+import os
+import sys
+from pathlib import Path
+
+import torch
+
+_MODEL = {}
+
+
+def _load(code, qwen_path, flux2_src):
+    if "m" not in _MODEL:
+        sys.path.insert(0, str(Path(code) / "src"))
+        from imagewam.models.backbones.flux2_imports import ensure_flux2_importable
+        ensure_flux2_importable(str(flux2_src))
+        from flux2.text_encoder import OUTPUT_LAYERS_QWEN3
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        torch.set_num_threads(min(32, os.cpu_count() or 8))
+        tok = AutoTokenizer.from_pretrained(str(qwen_path))
+        model = AutoModelForCausalLM.from_pretrained(str(qwen_path), torch_dtype=torch.bfloat16).eval()
+        _MODEL["m"] = (tok, model, tuple(OUTPUT_LAYERS_QWEN3))
+    return _MODEL["m"]
+
+
+def embed(prompt, code, qwen_path, flux2_src, context_len=128):
+    tok, model, layers = _load(code, qwen_path, flux2_src)
+    rendered = tok.apply_chat_template([{"role": "user", "content": prompt}], tokenize=False,
+                                       add_generation_prompt=True, enable_thinking=False)
+    enc = tok([rendered], return_tensors="pt", padding="max_length", truncation=True, max_length=context_len)
+    with torch.no_grad():
+        out = model(input_ids=enc.input_ids, attention_mask=enc.attention_mask, output_hidden_states=True,
+                    use_cache=False)
+    hidden = torch.stack([out.hidden_states[k] for k in layers], dim=1)       # [1, c, l, d]
+    hidden = hidden.permute(0, 2, 1, 3).reshape(1, context_len, -1)           # b l (c d)
+    return dict(text_hidden_states=hidden[0].to(torch.bfloat16).clone(),
+                text_attention_mask=enc.attention_mask[0].to(torch.bool).clone())
+
+
+def cache_name(prompt, context_len=128):
+    return f"{hashlib.sha256(prompt.encode('utf-8')).hexdigest()}.qwen3_flux2_len{context_len}.pt"
+
+
+def check_reference(ref_prompt, ref_dir, code, qwen_path, flux2_src):
+    ref = torch.load(Path(ref_dir) / cache_name(ref_prompt), map_location="cpu", weights_only=True)
+    new = embed(ref_prompt, code, qwen_path, flux2_src)
+    if not torch.equal(ref["text_attention_mask"].bool(), new["text_attention_mask"]):
+        raise SystemExit("qwen cache: attention mask differs from the reference cache")
+    m = ref["text_attention_mask"].bool()
+    a, b = ref["text_hidden_states"][m].float(), new["text_hidden_states"][m].float()
+    cos = torch.nn.functional.cosine_similarity(a, b, dim=-1)
+    rel = ((a - b).norm() / a.norm()).item()
+    info = dict(min_token_cosine=float(cos.min()), mean_token_cosine=float(cos.mean()), relative_l2=rel,
+                tokens=int(m.sum()))
+    if info["min_token_cosine"] < 0.99 or rel > 0.05:
+        raise SystemExit(f"qwen cache: CPU recomputation does not match the reference cache: {info}")
+    return info
+
+
+def make(prompt, out_dir, code, qwen_path, flux2_src, ref_prompt, ref_dir):
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    path = out_dir / cache_name(prompt)
+    if path.is_file():
+        return path, None
+    info = check_reference(ref_prompt, ref_dir, code, qwen_path, flux2_src)
+    payload = embed(prompt, code, qwen_path, flux2_src)
+    if not torch.isfinite(payload["text_hidden_states"].float()).all() or not payload["text_attention_mask"].any():
+        raise SystemExit("qwen cache: invalid embedding")
+    tmp = out_dir / f".{path.name}.tmp{os.getpid()}"
+    torch.save(payload, tmp)
+    os.replace(tmp, path)
+    return path, info

code/hb_deltaflow/train_deltaflow.py

@@ -0,0 +1,96 @@
+"""ImageWAM Delta-flow 40-epoch training entry (G1 B6/A3/A7 and H2 A18, 100 episodes, augmentation v2).
+
+Installed by prepare_deltaflow.py / prepare_deltaflow_a18.py as <code>/scripts/wholebody/train_deltaflow.py.
+Derived from train_a3a7.py:
+- same native runtime/trainer, same 32-GPU loader-length checks and finish receipts;
+- no separate 1-update smoke phase (the supervisor retries / resumes instead);
+- every save (epoch 10/20/30/40) writes weights + full training state; the trainer keeps all four weight files
+  (keep_latest_weights=4) and only the newest training state (keep_latest_state_only=true);
+- --resume <run/production/checkpoints/state/step_N> continues an interrupted run from its newest state.
+"""
+import argparse
+import json
+from pathlib import Path
+
+from omegaconf import OmegaConf
+from imagewam import runtime
+from imagewam.trainer import Wan22Trainer
+
+# dataset class -> required train_split_mode (None: the loader itself admits exactly episodes 0-99)
+DATASET_TARGETS = {
+    'imagewam.datasets.wholebody_hbaug.WholeBodyHBAugV2LeRobotDataset': 'first_100',   # G1: B6 / A3 / A7
+    'imagewam.datasets.h2_hbaug.H2HBAugV2Dataset': None,                               # H2: A18
+}
+AUG_VERSION = 'hb-aug-v2-20261109'
+EPOCHS, SAVE_EVERY_EPOCHS, WARMUP_EPOCHS, WORLD = 40, 10, 2, 32
+EXPECTED = {}
+
+
+def require(condition, message):
+    if not condition:
+        raise RuntimeError(message)
+
+
+class DeltaFlowTrainer(Wan22Trainer):
+    def _resume_or_load_checkpoint(self):
+        require(len(self.train_dataset) == EXPECTED['frames'] and len(self.train_loader) == EXPECTED['updates_per_epoch']
+                and self.accelerator.num_processes == WORLD,
+                'Expected the pinned 100-episode collection, its updates/epoch and 32 GPUs')
+        require(type(self.train_dataset).__name__ in {t.rsplit('.', 1)[1] for t in DATASET_TARGETS},
+                'Augmentation v2 dataset missing')
+        return super()._resume_or_load_checkpoint()
+
+    def train(self):
+        start = int(self.global_step)
+        super().train()
+        engine = self.accelerator.deepspeed_engine_wrapped.engine
+        require(self.global_step == self.max_steps and engine.skipped_steps == 0,
+                'Training ended without reaching its optimizer-update target')
+        if not self.resume:
+            require(engine.global_steps == self.global_step, 'Trainer and optimizer update counts differ')
+        rank = self.accelerator.process_index
+        path = Path(self.output_dir) / f'finish-rank-{rank:02d}.json'
+        path.write_text(json.dumps({'rank': rank, 'global_step': self.global_step,
+                                    'optimizer_steps': int(engine.global_steps), 'resumed_from_step': start}) + '\n')
+        self.accelerator.wait_for_everyone()
+
+
+def check_config(cfg, root, resume):
+    receipt = json.loads((root / 'data-verified.json').read_text())
+    u = int(receipt['updates_per_epoch'])
+    total = EPOCHS * u
+    EXPECTED.update(frames=int(receipt['frames']), updates_per_epoch=u)
+    d = cfg.data.train
+    require(d._target_ in DATASET_TARGETS and d.image_augmentation.version == AUG_VERSION
+            and d.image_augmentation.enabled is True, 'Config does not use augmentation v2')
+    split_mode = DATASET_TARGETS[d._target_]
+    require((split_mode is None or d.train_split_mode == split_mode) and receipt['train_episode_ids'] == list(range(100)),
+            'Training must use exactly episodes 0-99')
+    require(cfg.num_epochs == EPOCHS and cfg.max_steps == total and cfg.lr_scheduler_total_steps == total
+            and cfg.warmup_steps == WARMUP_EPOCHS * u, 'Epoch/step schedule differs from 40 x updates_per_epoch')
+    require(list(cfg.save_steps) == [e * u for e in range(SAVE_EVERY_EPOCHS, EPOCHS + 1, SAVE_EVERY_EPOCHS)]
+            and cfg.save_every == 0 and cfg.save_at_end is True and cfg.keep_latest_weights == 4
+            and cfg.keep_latest_state_only is True, 'Checkpoint policy differs (epochs 10/20/30/40, newest state only)')
+    output = Path(cfg.output_dir).resolve()
+    require(output == (root / 'run' / 'production').resolve(), 'Unexpected output directory')
+    require(cfg.resume is None, 'Pass --resume on the command line, not in the YAML')
+    if resume is None:
+        weights = list((output / 'checkpoints' / 'weights').glob('*.pt'))
+        require(not weights, 'Fresh start into an output directory that already holds weights')
+        return
+    state = Path(resume).resolve()
+    require(state.parent == output / 'checkpoints' / 'state' and (state / 'trainer_state.json').is_file(),
+            f'Invalid resume state {state}')
+    cfg.resume = str(state)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', type=Path, required=True)
+    parser.add_argument('--resume', default=None)
+    args = parser.parse_args()
+    config = args.config.resolve()
+    cfg = OmegaConf.load(config)
+    check_config(cfg, config.parent.parent, args.resume)
+    runtime.Wan22Trainer = DeltaFlowTrainer
+    runtime.run_training(cfg)

code/hb_deltaflow/verify_cpu.py

@@ -0,0 +1,381 @@
+"""CPU verification of the Delta-flow 40-epoch package (run on a node after prepare_deltaflow.py; no GPU used).
+
+    $P/venv/bin/python $G/hb_deltaflow/verify_cpu.py                 # aug checks + b6 a3 a7
+    $P/venv/bin/python $G/hb_deltaflow/verify_cpu.py b6 --samples 48
+    $P/venv/bin/python $G/hb_deltaflow/verify_cpu.py --aug-only      # before prepare: hb_aug_v2 from $G/hb_groot
+Checks
+  1. hb_aug_v2 parameter statistics: each of the 15 effects is the 1.5x boost ~1/15 of the time, trigger rates match
+     the spec, 1x and 1.5x ranges are respected and the boosted range is actually reached.
+  2. hb_aug_v2.apply per effect in isolation: every effect changes the observation frame; colour / rotation-crop /
+     light / white balance also change the t+16 target, sensor/optics effects leave the target untouched.
+  3. per task: manifest / statistics cover exactly episodes 0-99 (B6 shelves 100-148), YAML has the
+     40-epoch schedule and epoch 10/20/30/40 saves and NO joint velocity anywhere (user rule 2026-11-10), then one
+     real augmented batch: shapes, labels unchanged, target frame = colour/geometry/light/WB only, proprio 44-D
+     (G1: body 29 + hands 12 + gravity 3) / 78-D (H2: 75 joints + gravity 3) with untouched hands/gravity when not
+     delayed.
+"""
+import argparse
+import json
+import math
+from pathlib import Path
+import sys
+
+import numpy as np
+import torch
+
+H = Path(__file__).resolve().parent
+G = H.parent
+CODE = G / 'deltaflow-runs' / 'HumanWAM'
+CODE_H2 = G / 'deltaflow-runs' / 'HumanWAM-h2'
+ROOT = G / 'deltaflow-runs'
+CONTROL_HZ = {'b6': 50, 'a3': 30, 'a7': 30}
+TOTAL_EPISODES = {'b6': 149, 'a3': 100, 'a7': 100}
+# src/imagewam/wholebody_delta.py of the 44-D reference run $P/real30-from-sim60-20261108/HumanWAM
+REF_DELTA_SHA256 = '523244263496679f7046035f5df3d34590b7086e25173938d8a175dad963b9f3'
+FAILURES = []
+
+
+def check(condition, message):
+    print(('  ok   ' if condition else '  FAIL ') + message, flush=True)
+    if not condition:
+        FAILURES.append(message)
+
+
+def velocity_entries(value, path='cfg'):
+    """Config entries that would add joint velocity (non-empty velocity_* settings or velocity file references)."""
+    found = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if 'velocity' in str(key).lower() and item not in ([], None, False, 0):
+                found.append(f'{path}.{key}')
+            found += velocity_entries(item, f'{path}.{key}')
+    elif isinstance(value, list):
+        for i, item in enumerate(value):
+            found += velocity_entries(item, f'{path}[{i}]')
+    elif isinstance(value, str) and 'velocity' in value.lower() and 'no velocity' not in value.lower():
+        found.append(path)
+    return found
+
+
+SENSOR = ('noise', 'gaussian_blur', 'jpeg', 'motion_blur', 'sharpen', 'defocus')
+PROB = {'noise': .5, 'gaussian_blur': .15, 'jpeg': .35, 'motion_blur': .15, 'sharpen': .15, 'defocus': .10,
+        'light_shadow': .30, 'wb_channel': .30}
+
+
+def active(p, name):
+    value = p[name]
+    return value is not None and value != 0.0
+
+
+def check_parameters(A, n=15000):
+    print('[1] hb_aug_v2 parameter statistics, n=%d' % n)
+    check(len(A.EFFECTS) == 15 and A.VERSION == 'hb-aug-v2-20261109', f'15 effects, version {A.VERSION}')
+    rng = np.random.default_rng(1234)
+    draws = [A.sample(rng, 2, 224) for _ in range(n)]
+    counts = {e: sum(p['boost'] == e for p in draws) for e in A.EFFECTS}
+    band = 5 * math.sqrt(n / 15)
+    check(all(abs(c - n / 15) < band for c in counts.values()), f'boost uniform over 15 effects: {counts}')
+    for name, prob in PROB.items():
+        rate = sum(active(p, name) for p in draws) / n
+        check(abs(rate - prob) < 0.03, f'{name} trigger rate {rate:.3f} (spec {prob})')
+
+    def span(name, value_fn, lo1, hi1, lo15, hi15):
+        normal = [v for p in draws if p['boost'] != name for v in value_fn(p)]
+        boosted = [v for p in draws if p['boost'] == name for v in value_fn(p)]
+        ok = (normal and boosted and lo1 - 1e-9 <= min(normal) and max(normal) <= hi1 + 1e-9
+              and lo15 - 1e-9 <= min(boosted) and max(boosted) <= hi15 + 1e-9
+              and (min(boosted) < lo1 - 1e-6 or max(boosted) > hi1 + 1e-6))
+        check(bool(ok), f'{name}: x1 in [{lo1},{hi1}], x1.5 in [{lo15},{hi15}] and beyond x1 '
+                        f'(seen x1 {min(normal):.4g}..{max(normal):.4g}, x1.5 {min(boosted):.4g}..{max(boosted):.4g})')
+
+    span('exposure', lambda p: [p['exposure']], -.22, .22, -.33, .33)
+    span('contrast', lambda p: [p['contrast']], .88, 1.12, .82, 1.18)
+    span('saturation', lambda p: [p['saturation']], .76, 1.24, .64, 1.36)
+    span('hue', lambda p: [p['hue']], -.015, .015, -.0225, .0225)
+    span('gamma', lambda p: [p['gamma']], .89, 1.11, .835, 1.165)
+    span('temperature', lambda p: [p['temperature']], -.066, .066, -.099, .099)
+    span('rotation_crop', lambda p: [a for a, _ in p['geometry']], -1.5, 1.5, -2.25, 2.25)
+    span('rotation_crop', lambda p: [s - 1 - abs(a) * .015 for a, s in p['geometry']], 0, .02, 0, .03)
+    span('noise', lambda p: [p['noise']] if p['noise'] else [], 4 / 255, 4 / 255, 6 / 255, 6 / 255)
+    span('gaussian_blur', lambda p: [p['gaussian_blur']] if p['gaussian_blur'] else [], .25, .65, .375, .975)
+    span('jpeg', lambda p: [p['jpeg']] if p['jpeg'] is not None else [], 70, 95, 55, 92)
+    span('motion_blur', lambda p: [p['motion_blur'][0]] if p['motion_blur'] else [], 3, 7, 4.5, 10.5)
+    span('sharpen', lambda p: [p['sharpen']] if p['sharpen'] else [], .2, .6, .3, .9)
+    span('defocus', lambda p: [p['defocus']] if p['defocus'] else [], 1, 2, 1.5, 3)
+    span('light_shadow', lambda p: [b[3] for cam in (p['light_shadow'] or []) for b in cam], .7, 1.3, .55, 1.45)
+    span('wb_channel', lambda p: [g for cam in (p['wb_channel'] or []) for g in cam if g != 1.0], .9, 1.1, .85, 1.15)
+    angles = [p['motion_blur'][1] for p in draws if p['motion_blur']]
+    check(min(angles) >= 0 and max(angles) <= 180, 'motion blur direction in 0-180 deg')
+    blobs = [cam for p in draws if p['light_shadow'] for cam in p['light_shadow']]
+    check(all(1 <= len(c) <= 2 and all(.15 <= b[2] <= .35 for b in c) for c in blobs),
+          'light: 1-2 patches per camera, size 15-35 % of the frame')
+    wb = [cam for p in draws if p['wb_channel'] for cam in p['wb_channel']]
+    check(all(sum(g != 1.0 for g in cam) <= 1 for cam in wb), 'white balance: one channel per camera')
+    geometry_differs = sum(p['geometry'][0] != p['geometry'][1] for p in draws) / n
+    check(geometry_differs > .99, 'rotation/crop drawn independently per camera')
+
+
+def identity(views=2):
+    return {'boost': None, 'exposure': 0.0, 'contrast': 1.0, 'saturation': 1.0, 'hue': 0.0, 'gamma': 1.0,
+            'temperature': 0.0, 'geometry': [(0.0, 1.0)] * views, 'noise': 0.0, 'gaussian_blur': 0.0, 'jpeg': None,
+            'motion_blur': None, 'sharpen': 0.0, 'defocus': 0.0, 'light_shadow': None, 'wb_channel': None}
+
+
+def test_image():
+    yy, xx = torch.meshgrid(torch.linspace(0, 1, 224), torch.linspace(0, 1, 224), indexing='ij')
+    gen = torch.Generator().manual_seed(7)
+    frames = []
+    for t in range(2):
+        cams = []
+        for v in range(2):
+            base = torch.stack([0.2 + 0.6 * xx, 0.2 + 0.6 * yy, 0.5 + 0.3 * torch.sin(12 * xx + 7 * yy + t + v)])
+            checker = ((torch.floor(xx * 16) + torch.floor(yy * 16)) % 2) * 0.15
+            cams.append((base * 0.8 + checker + 0.05 * torch.rand(3, 224, 224, generator=gen)).clamp(0, 1))
+        frames.append(torch.stack(cams))
+    return torch.stack(frames)                                     # [T=2, V=2, 3, 224, 224]
+
+
+def check_apply(A):
+    print('[2] hb_aug_v2.apply: every effect fires, observation-only vs target rules')
+    x = test_image()
+    obs = torch.tensor([True, False])
+    ref = A.apply(x, identity(), obs)
+    check((ref - x).abs().max().item() < 2e-3, 'identity parameters leave the frames unchanged')
+    settings = {
+        'exposure': {'exposure': .3}, 'contrast': {'contrast': 1.15}, 'saturation': {'saturation': 1.3},
+        'hue': {'hue': .02}, 'gamma': {'gamma': 1.15}, 'temperature': {'temperature': .09},
+        'rotation_crop': {'geometry': [(2.0, 1.05), (-2.0, 1.04)]}, 'noise': {'noise': 6 / 255},
+        'gaussian_blur': {'gaussian_blur': .9}, 'jpeg': {'jpeg': 55}, 'motion_blur': {'motion_blur': (9.0, 30.0)},
+        'sharpen': {'sharpen': .8}, 'defocus': {'defocus': 2.5},
+        'light_shadow': {'light_shadow': [[(.5, .5, .25, 1.4)], [(.3, .6, .2, .6)]]},
+        'wb_channel': {'wb_channel': [[1.0, 1.12, 1.0], [0.88, 1.0, 1.0]]},
+    }
+    check(sorted(settings) == sorted(A.EFFECTS), 'all 15 effects exercised')
+    for name, change in settings.items():
+        p = dict(identity(), **change)
+        y = A.apply(x, p, obs, noise_seed=3)
+        d_obs = [(y[0, v] - ref[0, v]).abs().mean().item() for v in range(2)]
+        d_tgt = [(y[1, v] - ref[1, v]).abs().max().item() for v in range(2)]
+        fires = min(d_obs) > 5e-4
+        if name in SENSOR:
+            check(fires and max(d_tgt) < 1e-6, f'{name}: observation changed {min(d_obs):.4f}, target untouched')
+        else:
+            check(fires and min((y[1, v] - ref[1, v]).abs().mean().item() for v in range(2)) > 5e-4,
+                  f'{name}: observation and t+16 target both changed')
+    p = dict(identity(), exposure=.3, saturation=1.3)
+    y = A.apply(x, p, obs)
+    same_colour = all(torch.allclose(y[t, v], A.apply(x[t:t + 1, v:v + 1], dict(p, geometry=[(0.0, 1.0)]),
+                                                      torch.tensor([t == 0]))[0, 0], atol=1e-5)
+                      for t in range(2) for v in range(2))
+    check(same_colour, 'one colour parameter set applied identically to both cameras and both times')
+
+
+def check_task(task, A, samples):
+    import yaml
+    from hydra.utils import instantiate
+    from omegaconf import OmegaConf
+    from torch.utils.data import default_collate
+    from imagewam.datasets.wholebody import WholeBodyLeRobotDataset
+    R = ROOT / task
+    print(f'[3] task {task}: {R}')
+    check((R / 'prepared.ok').is_file(), 'prepared.ok present')
+    receipt = json.loads((R / 'data-verified.json').read_text())
+    u, frames = receipt['updates_per_epoch'], receipt['frames']
+    train = list(range(100))
+    shelved = list(range(100, TOTAL_EPISODES[task]))
+    manifest = json.loads((R / 'split-manifest.json').read_text())
+    stats = json.loads((R / 'stats/dataset_stats.json').read_text())
+    check(manifest['train_episode_ids'] == train and manifest['validation_episode_ids'] == shelved,
+          f'split manifest trains 0-99, shelves {len(shelved)} episodes')
+    check(stats['train_episode_ids'] == train and stats['heldout_episode_ids'] == shelved
+          and stats['train_frames'] == frames and stats['train_split_mode'] == 'first_100',
+          f'normalization statistics fit on episodes 0-99 only ({frames} frames)')
+    check(not (R / 'stats/velocity.npz').exists() and not list(R.rglob('*velocity*')), 'no velocity cache / statistics files')
+    cfg = yaml.safe_load((R / 'run/production.yaml').read_text())
+    left = velocity_entries(cfg)
+    check(not left, f'config has no joint-velocity setting ({left or "none"})')
+    d = cfg['data']['train']
+    saves = [e * u for e in (10, 20, 30, 40)]
+    check(cfg['num_epochs'] == 40 and cfg['max_steps'] == cfg['lr_scheduler_total_steps'] == 40 * u
+          and cfg['warmup_steps'] == 2 * u and cfg['save_steps'] == saves and cfg['save_every'] == 0
+          and cfg['keep_latest_weights'] == 4 and cfg['keep_latest_state_only'] is True and cfg['save_at_end'] is True,
+          f'schedule: {u} updates/epoch, max_steps {40 * u}, warmup {2 * u}, saves {saves}, newest state only')
+    check(d['proprio_augmentation']['control_hz'] == CONTROL_HZ[task] and d['proprio_augmentation']['recording_hz'] == 30,
+          f'control {CONTROL_HZ[task]} Hz / record 30 Hz')
+    check(d['_target_'].endswith('WholeBodyHBAugV2LeRobotDataset')
+          and d['image_augmentation']['version'] == A.VERSION, 'dataset class uses hb_aug_v2')
+    check(cfg['model']['proprio_dim'] == cfg['model']['action_state_dim'] == 44 and cfg['model']['expected_action_dim'] == 76,
+          'model 44-D state (no velocity) / 76-D action, as reference real30-from-sim60-20261108')
+    check(d['_target_'].endswith('WholeBodyHBAugV2LeRobotDataset') and not d['proprio_augmentation'].get('velocity_channels'),
+          'loader = WholeBodyRobust-based HB aug v2, velocity_channels empty')
+    # the model factory itself (2026-11-10: config + data said 44 but the factory of the B6 60-epoch copy required 73)
+    import hashlib
+    import inspect
+    import re
+    import imagewam.wholebody_delta as model_module
+    src = Path(model_module.__file__).read_bytes()
+    sig = inspect.signature(model_module.create_imagewam_flux2_wholebody_delta)
+    check(cfg['model']['_target_'] == 'imagewam.wholebody_delta.create_imagewam_flux2_wholebody_delta'
+          and sig.parameters['action_state_dim'].default == 44 and 'state44' in model_module.SCHEMA_ID
+          and b'(None, 44)' in src and re.search(rb'\b73\b', src) is None
+          and hashlib.sha256(src).hexdigest() == REF_DELTA_SHA256,
+          'model factory wholebody_delta.py = state44 copy of real30-from-sim60-20261108 (no 73 anywhere)')
+
+    dataset = instantiate(OmegaConf.load(R / 'run/production.yaml').data.train)
+    check(len(dataset) == frames and list(dataset.episode_ids) == train, f'dataset = episodes 0-99, {len(dataset)} samples')
+    rng = np.random.default_rng(99)
+    index = sorted(set(rng.integers(0, len(dataset), samples).tolist()) | {0})
+    batch, boosts, target_ok, obs_ok, label_ok, hands_ok, episodes = [], [], 0, 0, 0, 0, set()
+    not_delayed = 0
+    for i in index:
+        sample = dataset[i]
+        info = dataset.last_augmentation
+        base = WholeBodyLeRobotDataset.__getitem__(dataset, i)
+        p = info['visual']
+        boosts.append(p['boost'])
+        episodes.add(sample['episode_index'])
+        views = torch.stack((((base['video'].permute(1, 0, 2, 3) + 1) * .5).clamp(0, 1)).chunk(2, dim=-1), dim=1)
+        clean = A.apply(views, p, torch.tensor([False, False]))
+        got = torch.stack((((sample['video'].permute(1, 0, 2, 3) + 1) * .5)).chunk(2, dim=-1), dim=1)
+        target_ok += bool(torch.allclose(got[1], clean[1], atol=1e-4))
+        sensor = any(active(p, k) for k in SENSOR)
+        d0 = (got[0] - clean[0]).abs().max().item()
+        obs_ok += (d0 > 1e-6) if sensor else (d0 < 1e-4)
+        label_ok += bool(torch.equal(sample['action'], base['action']))
+        if info['numeric']['delay_recorded_frames'] == 0:
+            not_delayed += 1
+            hands_ok += bool(torch.allclose(sample['proprio'][:, 29:44], base['proprio'][:, 29:44])
+                             and not torch.allclose(sample['proprio'][:, :29], base['proprio'][:, :29]))
+        batch.append(sample)
+    n = len(index)
+    check(target_ok == n, f't+16 target = colour/geometry/light/WB only, no sensor effects ({target_ok}/{n})')
+    check(obs_ok == n, f'observation frame gets the sensor/optics effects when drawn ({obs_ok}/{n})')
+    check(label_ok == n, f'action labels identical to the un-augmented loader ({label_ok}/{n})')
+    check(hands_ok == not_delayed, f'undelayed samples: hands/gravity untouched, body joints perturbed ({hands_ok}/{not_delayed})')
+    check(max(episodes) < 100, f'samples only from episodes < 100 (max {max(episodes)})')
+    check(len(set(boosts)) >= min(8, n // 3), f'boosted effects seen: {sorted(set(boosts))}')
+    check(all(s['proprio'].shape[-1] == 44 for s in batch), 'every sample proprio is 44-D (no velocity)')
+    b = default_collate(batch[:8])
+    k = len(batch[:8])
+    shapes = {key: tuple(b[key].shape) for key in ('video', 'action', 'past_action', 'proprio', 'text_hidden_states')}
+    check(shapes == {'video': (k, 3, 2, 224, 448), 'action': (k, 16, 76), 'past_action': (k, 16, 76),
+                     'proprio': (k, 16, 44), 'text_hidden_states': (k, 128, 7680)}, f'batch shapes {shapes}')
+    check(bool(torch.isfinite(b['proprio']).all()) and b['video'].min() >= -1 and b['video'].max() <= 1,
+          'finite proprio, video in [-1,1]')
+
+
+def check_task_h2(A, samples):
+    """A18 / H2: 75-D action, 78-D proprio (75 joints + gravity 3, NO velocity), cameras head + chest."""
+    import yaml
+    from hydra.utils import instantiate
+    from omegaconf import OmegaConf
+    from torch.utils.data import default_collate
+    from imagewam.datasets.h2_pour import CAMERAS, H2PourDataset
+    import imagewam.h2_pour_delta as model_module
+    R = ROOT / 'a18'
+    print(f'[3] task a18 (H2): {R}')
+    check((R / 'prepared.ok').is_file(), 'prepared.ok present')
+    receipt = json.loads((R / 'data-verified.json').read_text())
+    u, frames = receipt['updates_per_epoch'], receipt['frames']
+    check(frames == 72752 and u == 285 and receipt['train_episode_ids'] == list(range(100)),
+          f'A18: 100 episodes, {frames} frames, {u} updates/epoch')
+    check(not list(R.rglob('*velocity*')), 'no velocity cache / statistics files')
+    cfg = yaml.safe_load((R / 'run/production.yaml').read_text())
+    d, m = cfg['data']['train'], cfg['model']
+    left = velocity_entries(cfg)
+    check(not left and not d['proprio_augmentation'].get('velocity_channels'),
+          f'config has no joint-velocity setting ({left or "none"})')
+    saves = [e * u for e in (10, 20, 30, 40)]
+    check(cfg['num_epochs'] == 40 and cfg['max_steps'] == cfg['lr_scheduler_total_steps'] == 40 * u
+          and cfg['warmup_steps'] == 2 * u and cfg['save_steps'] == saves and cfg['save_every'] == 0
+          and cfg['keep_latest_weights'] == 4 and cfg['keep_latest_state_only'] is True and cfg['save_at_end'] is True,
+          f'schedule: max_steps {40 * u}, warmup {2 * u}, saves {saves}, newest state only')
+    pa = d['proprio_augmentation']
+    check(d['_target_'].endswith('H2HBAugV2Dataset') and d['image_augmentation']['version'] == A.VERSION
+          and pa['affected_angle_channels'] == list(range(31)) and pa['control_hz'] == pa['recording_hz'] == 30,
+          'H2 dataset class, aug v2, bias/noise on state[0:31], 30 Hz delay conversion')
+    check('h2_pour_delta' in m['_target_'] and m['proprio_dim'] == m['action_state_dim'] == 78
+          and m['expected_action_dim'] == 75, f'model: original H2 h2_pour_delta, state 78 (no velocity) / action 75')
+    sig = __import__('inspect').signature(model_module.create_imagewam_flux2_wholebody_delta)
+    check(sig.parameters['action_state_dim'].default == 78, 'h2_pour_delta factory default state 78')
+    check(list(CAMERAS) == ['observation.images.head', 'observation.images.chest'], f'cameras {list(CAMERAS)}')
+
+    dataset = instantiate(OmegaConf.load(R / 'run/production.yaml').data.train)
+    check(len(dataset) == frames, f'dataset {len(dataset)} samples')
+    rng = np.random.default_rng(99)
+    index = sorted(set(rng.integers(0, len(dataset), samples).tolist()) | {0})
+    batch, boosts, target_ok, obs_ok, label_ok, hands_ok, not_delayed = [], [], 0, 0, 0, 0, 0
+    for i in index:
+        sample = dataset[i]
+        info = dataset.last_augmentation
+        base = H2PourDataset.__getitem__(dataset, i)          # parent path: augmentation disabled, 78-D state
+        p = info['visual']
+        boosts.append(p['boost'])
+        views = torch.stack((((base['video'].permute(1, 0, 2, 3) + 1) * .5).clamp(0, 1)).chunk(2, dim=-1), dim=1)
+        clean = A.apply(views, p, torch.tensor([False, False]))
+        got = torch.stack((((sample['video'].permute(1, 0, 2, 3) + 1) * .5)).chunk(2, dim=-1), dim=1)
+        target_ok += bool(torch.allclose(got[1], clean[1], atol=1e-4))
+        d0 = (got[0] - clean[0]).abs().max().item()
+        obs_ok += (d0 > 1e-6) if any(active(p, k) for k in SENSOR) else (d0 < 1e-4)
+        label_ok += bool(torch.equal(sample['action'], base['action']))
+        numeric = info['numeric']
+        if numeric['delay_recorded_frames'] == 0:
+            not_delayed += 1
+            hands_ok += bool(torch.allclose(sample['proprio'][:, 31:78], base['proprio'][:, 31:78])
+                             and not torch.allclose(sample['proprio'][:, :31], base['proprio'][:, :31]))
+        batch.append(sample)
+    n = len(index)
+    check(target_ok == n, f't+16 target = colour/geometry/light/WB only ({target_ok}/{n})')
+    check(obs_ok == n, f'observation frame gets the sensor/optics effects when drawn ({obs_ok}/{n})')
+    check(label_ok == n, f'action labels identical to the un-augmented H2 loader ({label_ok}/{n})')
+    check(all(s['proprio'].shape[-1] == 78 for s in batch), 'every sample proprio is 78-D (no velocity)')
+    check(hands_ok == not_delayed, f'undelayed: hands/gravity untouched, 31 body joints perturbed ({hands_ok}/{not_delayed})')
+    check(len(set(boosts)) >= min(8, n // 3), f'boosted effects seen: {sorted(set(boosts))}')
+    b = default_collate(batch[:8])
+    k = len(batch[:8])
+    shapes = {key: tuple(b[key].shape) for key in ('video', 'action', 'past_action', 'proprio', 'proprio_dim_is_pad')}
+    check(shapes == {'video': (k, 3, 2, 224, 448), 'action': (k, 16, 75), 'past_action': (k, 16, 75),
+                     'proprio': (k, 16, 78), 'proprio_dim_is_pad': (k, 78)}, f'batch shapes {shapes}')
+    check(bool(torch.isfinite(b['proprio']).all()) and b['video'].min() >= -1 and b['video'].max() <= 1,
+          'finite proprio, video in [-1,1]')
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('tasks', nargs='*', default=['b6', 'a3', 'a7', 'a18'])
+    parser.add_argument('--samples', type=int, default=32)
+    parser.add_argument('--aug-only', action='store_true')
+    parser.add_argument('--skip-aug', action='store_true', help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    torch.set_num_threads(4)
+    g1 = [t for t in args.tasks if t != 'a18']
+    h2_rc = 0
+    if 'a18' in args.tasks and g1 and not args.aug_only:
+        # The H2 code tree has its own imagewam package: check A18 in a separate interpreter.
+        import subprocess
+        h2_rc = subprocess.call([sys.executable, __file__, 'a18', '--samples', str(args.samples), '--skip-aug'])
+    h2_only = args.tasks == ['a18'] and not args.aug_only
+    if args.aug_only:
+        sys.path.insert(0, str(G / 'hb_groot'))
+        import hb_aug_v2 as A
+    else:
+        sys.path.insert(0, str((CODE_H2 if h2_only else CODE) / 'src'))
+        from imagewam.datasets import hb_aug_v2 as A
+    print('hb_aug_v2 from', A.__file__)
+    if not args.skip_aug:
+        check_parameters(A)
+        check_apply(A)
+    if not args.aug_only:
+        if h2_only:
+            check_task_h2(A, args.samples)
+        else:
+            for task in g1:
+                check_task(task, A, args.samples)
+    if h2_rc:
+        FAILURES.append('a18 sub-check failed (see its output above)')
+    print('VERIFY_FAIL %d' % len(FAILURES) if FAILURES else 'VERIFY_OK', flush=True)
+    return 1 if FAILURES else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

code/hb_deltaflow/wholebody_hbaug.py

@@ -0,0 +1,101 @@
+"""ImageWAM Delta-flow loader with Humanoid Benchmark augmentation spec v2 (project CLAUDE.md), proprio aligned with
+the GR00T A20 recipe (2026-11-12).
+
+Installed by prepare_deltaflow.py as imagewam/datasets/wholebody_hbaug.py, next to an unchanged copy of
+$G/hb_groot/hb_aug_v2.py (the implementation shared by GR00T / pi0.5 / Psi-Zero / DiT4DiT).
+
+Base class: WholeBodyRobustLeRobotDataset (wholebody_augmented_v3), the loader of the reference run
+HF humanoid-benchmark/b6-imagewam-deltaflow76 real30-from-sim60-20261108 (proprio_dim 44, velocity_channels []).
+NO joint velocity (user rule 2026-11-10): the model input is exactly 44-D = body joints 29 + measured hands 12 +
+projected gravity 3. Any velocity argument or any proprio width other than 44 is an error.
+
+Visual: hb_aug_v2.augment on [T=2, V=2, 3, 224, 224]: one of the 15 effects uniformly boosted to 1.5x per sample;
+colour shared over both cameras and both times; rotation/crop, light patches and single-channel white balance drawn
+per camera and applied identically to the observation (t) and the future target (t+16); noise / gaussian blur / JPEG /
+motion blur / sharpen / defocus only on the observation frame.
+Proprio (2026-11-12, user: align every model with GR00T's A20 basket-transfer training, hb_groot/hb_launch.py):
+hb_aug_v2.perturb_joints on the 29 body joints of the CURRENT frame, i.e. a fresh uniform +-2 deg bias per joint and
+per sample plus N(0, 0.25 deg) noise clipped at 3 sigma; NO proprio delay, NO action-history drop (the parent class's
+per-episode bias, 15 % delay and 15 % history drop are replaced). Labels (action, measured hands) are never modified.
+"""
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import torch
+
+from . import hb_aug_v2
+from .wholebody_augmented_v3 import WholeBodyRobustLeRobotDataset
+
+SPEC_VERSION = "hb-aug-v2-20261109"
+PROPRIO_DIM = 44  # body 29 + hands 12 + gravity 3; NO velocity
+BODY = 29
+PROPRIO_SPEC = {"enabled": True, "joint_bias_degrees": 2.0, "joint_noise_std_degrees": 0.25,
+                "delay_probability": 0.0, "max_delay_control_cycles": 0, "recording_hz": 30,
+                "history_drop_probability": 0.0, "bias_scope": "per_sample",
+                "implementation": "hb_aug_v2.perturb_joints"}
+
+
+class WholeBodyHBAugV2LeRobotDataset(WholeBodyRobustLeRobotDataset):
+    def __init__(self, *, image_augmentation, proprio_augmentation, **kwargs):
+        velocity_args = sorted(k for k in kwargs if "velocity" in k)
+        if velocity_args:
+            raise ValueError(f"Joint velocity is not allowed in the model input (got {velocity_args})")
+        image_policy = dict(image_augmentation)
+        proprio_policy = dict(proprio_augmentation)
+        if hb_aug_v2.VERSION != SPEC_VERSION or image_policy.get("version") != SPEC_VERSION:
+            raise ValueError(f"Expected augmentation {SPEC_VERSION}, got module {hb_aug_v2.VERSION} / "
+                             f"config {image_policy.get('version')}")
+        if image_policy.get("enabled") is not True or "seed" not in image_policy:
+            raise ValueError("Augmentation v2 must be enabled and seeded")
+        for key, value in PROPRIO_SPEC.items():
+            if proprio_policy.get(key) != value:
+                raise ValueError(f"proprio_augmentation.{key}={proprio_policy.get(key)!r}, aligned spec needs {value!r}")
+        if list(proprio_policy.get("affected_angle_channels", [])) != list(range(BODY)):
+            raise ValueError("Bias/noise must hit exactly the 29 body joints")
+        if list(proprio_policy.get("velocity_channels") or []):
+            raise ValueError("velocity_channels must be empty (no joint velocity)")
+        super().__init__(image_augmentation=image_policy, proprio_augmentation=proprio_policy, **kwargs)
+
+    def __getitem__(self, index):
+        sample = super().__getitem__(index)
+        width = int(sample["proprio"].shape[-1])
+        pad = sample.get("proprio_dim_is_pad")
+        if width != PROPRIO_DIM or (pad is not None and int(pad.shape[-1]) != PROPRIO_DIM):
+            raise ValueError(f"proprio must be {PROPRIO_DIM}-D (no velocity), got {width}")
+        return sample
+
+    def augment_numeric(self, sample, rng):
+        episode = int(sample["episode_index"])
+        anchor = int(sample["frame_index"])
+        states, _ = self.episodes[episode]
+        state = states[anchor].copy()                                  # no delay: always the current frame
+        raw = state[:BODY].astype(np.float64)
+        state[:BODY] = hb_aug_v2.perturb_joints(state[:BODY], rng)     # per-sample bias +-2 deg + noise 0.25 deg
+        current = self.normalizer.forward(state, "state")
+        sample["proprio"] = torch.from_numpy(np.repeat(current[None], self.action_horizon, axis=0)).to(
+            dtype=sample["proprio"].dtype)
+        past = sample["past_action"].clone()
+        pad = sample["past_action_is_pad"].clone()
+        past[pad] = 0                                                  # unchanged history, no drop
+        sample["past_action"] = past
+        sample["past_action_is_pad"] = pad
+        return dict(delay_recorded_frames=0, history_drop_rows=[],
+                    joint_perturbation_degrees=(np.degrees(state[:BODY].astype(np.float64) - raw)).tolist())
+
+    def augment_video(self, video, rng):
+        # video: [3, T, 224, 2*224] in [-1, 1]; T=2 = (anchor t, future target t+16); width = ego_view | chest.
+        if (video.ndim != 4 or video.shape[0] != 3 or video.shape[1] != 2
+                or video.shape[-1] != 2 * video.shape[-2]):
+            raise ValueError(f"Expected [3,2,H,2H] ego|chest video, got {tuple(video.shape)}")
+        x = ((video.permute(1, 0, 2, 3) + 1.0) * 0.5).clamp(0, 1)
+        views = torch.stack(x.chunk(2, dim=-1), dim=1)              # [T, V=2, 3, H, W]
+        observation = torch.ones(views.shape[0], dtype=torch.bool)
+        observation[-1] = False                                       # t+16 is the supervised image target
+        out, params = hb_aug_v2.augment(views, rng, obs_mask=observation)
+        joined = torch.cat(list(out.unbind(1)), dim=-1)              # [T, 3, H, 2W]
+        return (joined * 2.0 - 1.0).permute(1, 0, 2, 3).contiguous().to(video.dtype), params
+
+
+assert math.isclose(PROPRIO_SPEC["joint_bias_degrees"], 2.0)