Phase 2.1A Robometer-Low training kit v2

.gitignore

@@ -0,0 +1,14 @@
+.venv/
+__pycache__/
+*.py[cod]
+*.pt
+*.pth
+*.safetensors
+*.npz
+hf_cache/
+runs/
+outputs/
+wandb/
+*.log
+.env
+*token*

README.md

@@ -0,0 +1,67 @@
+---
+library_name: transformers
+tags:
+  - robotics
+  - reward-modeling
+  - qwen3-vl
+  - peft
+  - private-training-code
+---
+
+# Cosmos–Robometer Phase 2.1A training code
+
+Private, portable training kit for the approved `Public-Proxy stage2_core_v1`
+experiments:
+
+- `Robometer-Low-LoRA`: implemented formal trainer with frozen ID-dev evaluation,
+  early stopping, and a 3,000-step hard cap.
+- `Robometer-Low`: full language-decoder smoke test. Formal training remains
+  intentionally blocked until suitable multi-GPU/server memory is available.
+
+No dataset files, model weights, checkpoints, Hugging Face cache, local virtual
+environment, credentials, OOD evaluation data, or machine-specific run logs are
+included.
+
+## Recreate the environment
+
+```bash
+uv python install 3.10.12
+uv sync --project environment/phase21a_robometer --frozen
+uv run --project environment/phase21a_robometer \
+  python environment/phase21a_robometer/doctor.py
+```
+
+The environment is locked for PyTorch 2.8.0/CUDA 12.8. The reference smoke
+hardware was one RTX 5090 with 32,607 MiB VRAM.
+
+## External inputs
+
+- Base model: `unsloth/Qwen3-VL-4B-Instruct` at revision
+  `252d592b59b0233b226875a44ac135cfa1d3f755`.
+- Dataset route: `Public-Proxy stage2_core_v1` derived from
+  `robometer/processed_datasets` at revision
+  `1a8eb2d279c70964fadeaf8019a77c490c3abe02`.
+- Frozen Phase 2.1A subset: 2,689 pair rows referencing 4,323 trajectory files.
+
+The planned dataset repository is
+`ar-mine/cosmos-robometer-public-dataset`.
+Until it is available, the subset can be reconstructed from the pinned official
+Robometer processed-data repository and the frozen dataset manifest.
+
+## Training
+
+See [TRAINING_MANUAL.md](TRAINING_MANUAL.md). The frozen LoRA configuration is
+`configs/phase21a_robometer_low_lora_train_v2.yaml`.
+
+## Current support boundary
+
+The LoRA trainer is runnable and validated at micro-batch 32, gradient
+accumulation 2, effective batch 64. The full-tune file is a capacity smoke test,
+not a formal distributed trainer. Paged 8-bit AdamW is not permitted for the
+formal `Robometer-Low` comparison.
+
+## Redistribution
+
+This private repository contains experiment code and metadata only. It does not
+grant redistribution rights for upstream datasets or model weights. Review the
+terms of each upstream source before making any derived dataset public.

TRAINING_MANUAL.md

@@ -0,0 +1,369 @@
+# Phase 2.1A 训练手册
+
+日期：2026-08-27  
+对象：`Robometer-Low-LoRA` 与 `Robometer-Low`  
+数据：`Public-Proxy stage2_core_v1` 的冻结 5% pair manifest
+
+## 1. 名称和不可变边界
+
+- `Robometer-Low-LoRA`：Qwen3-VL-4B 视觉塔和语言基座冻结；训练 attention LoRA、五个新增
+  token rows 和 progress/success/preference 三头。
+- `Robometer-Low`：视觉塔冻结；语言 decoder 全量微调；训练三个 heads；`use_peft=false`。
+- `Low` 只表示使用非完整版 Public-Proxy 数据，不表示量化或 LoRA。
+- 两者使用同一 2,021-pair train split、同一 A/B 联合输入、同一 8+8 帧、同一三损失合同。
+- Robometer-Low 正式训练只允许标准 `torch.optim.AdamW`；禁止 paged AdamW 8-bit。
+- OOD benchmark 不进入训练 loop、checkpoint selection 或超参数选择。
+
+冻结数据统计：2,689 rows，其中 train/dev/confirmation-dev/excluded 分别为
+2,021/108/538/22；manifest SHA256 为
+`c77642e3d34177d1bfbcebe8c97cdf0af952c83d95a677cf42d95426b6d49204`。
+
+## 2. 当前代码成熟度
+
+| 分支 | 状态 | 可以做什么 |
+|---|---|---|
+| Robometer-Low-LoRA v1 | 已按用户要求停止 | 日志到 step 246；最新完整 checkpoint 为 step 4 |
+| Robometer-Low-LoRA v2 | 已配置，未正式启动 | 3,000-step cap、在线 ID-dev、早停和最佳 checkpoint 恢复 |
+| Robometer-Low | 等待服务器资源和正式 runner | 单卡容量 smoke；不能把当前 smoke 当正式训练入口 |
+
+LoRA v1 已停止且不再续训。v2 使用全新 output root；禁止拿 v1 的 step-4 checkpoint 恢复到 v2，
+因为总预算、scheduler 和选择协议均已改变。
+
+## 3. 参考环境
+
+已验证环境：
+
+| 项目 | 版本 |
+|---|---|
+| OS | Ubuntu 22.04.5 LTS |
+| Python | 3.10.12 |
+| NVIDIA driver | 580.173.02 |
+| PyTorch / CUDA runtime | 2.8.0+cu128 / 12.8 |
+| torchvision | 0.23.0+cu128 |
+| transformers | 4.57.6 |
+| PEFT | 0.19.1 |
+| accelerate | 1.14.0 |
+| flash-attn | 2.8.3.post1 |
+| qwen-vl-utils | 0.0.14 |
+| NumPy / Pillow | 1.26.4 / 11.3.0 |
+
+可部署环境固定在 `environment/phase21a_robometer/pyproject.toml` 和 `uv.lock`，不复制 `.venv`：
+
+```bash
+cd /srv/phase21a-kit
+uv python install 3.10.12
+uv sync --project environment/phase21a_robometer --frozen
+uv run --project environment/phase21a_robometer \
+  python environment/phase21a_robometer/doctor.py
+```
+
+如果上传包内保存了相同 `pyproject.toml` 和 `uv.lock`，仍要在目标 CUDA/driver 上重新创建环境。
+不要为上传工具升级训练 venv；`hf` CLI 可使用单独小环境。
+
+## 4. 下载并固定输入
+
+以下使用示例变量；按服务器目录修改：
+
+```bash
+PHASE21A_KIT=/srv/phase21a-kit
+PHASE21A_DATA=/srv/phase21a-data
+PHASE21A_MODEL=/srv/models/qwen3-vl-4b-instruct-252d592
+PHASE21A_RUNS=/srv/phase21a-runs
+```
+
+下载 training kit 和 dataset：
+
+```bash
+hf download ar-mine/cosmos-robometer-private-code \
+  --revision <KIT_COMMIT> \
+  --local-dir "$PHASE21A_KIT"
+
+hf download ar-mine/cosmos-robometer-public-dataset \
+  --repo-type dataset \
+  --revision <DATA_COMMIT> \
+  --local-dir "$PHASE21A_DATA"
+```
+
+下载精确基础模型；不要使用浮动 `main`：
+
+```bash
+hf download unsloth/Qwen3-VL-4B-Instruct \
+  --revision 252d592b59b0233b226875a44ac135cfa1d3f755 \
+  --local-dir "$PHASE21A_MODEL"
+```
+
+## 5. 开跑前共同门禁
+
+### 5.1 文件完整性
+
+```bash
+cd "$PHASE21A_DATA"
+sha256sum --check SHA256SUMS
+```
+
+再运行 dataset bundle 工具的 dry-run，把 `--output-dir` 指向任意不会执行复制的路径：
+
+```bash
+cd "$PHASE21A_KIT"
+uv run --project environment/phase21a_robometer python scripts/build_phase21a_hf_dataset_bundle.py \
+  --manifest "$PHASE21A_DATA/manifests/phase2_remediation_pairs_v1.jsonl" \
+  --processed-root "$PHASE21A_DATA/processed_datasets" \
+  --output-dir /tmp/phase21a-dry-run
+```
+
+必须得到：2,689 rows、4,323 unique frame files、0 missing、7.908 GiB。
+
+### 5.2 GPU/软件门禁
+
+```bash
+nvidia-smi
+uv run --project environment/phase21a_robometer \
+  python environment/phase21a_robometer/doctor.py
+```
+
+必须确认：BF16 可用、FlashAttention 2 可加载、模型 snapshot 离线可读、目标输出盘有足够空间。
+
+### 5.3 数据和评测隔离
+
+- formal trainer 只读取 `split=train` 且 `sample_type=preference`，精确为 2,021 pairs。
+- dev/confirmation-dev 只能用于 ID 报告或预注册 checkpoint selection。
+- `excluded_original_dev_component` 不得回流训练。
+- RBM-EVAL-OOD 不下载到训练节点也可以；不得据其结果调参。
+
+## 6. Robometer-Low-LoRA
+
+### 6.1 冻结配置
+
+| 参数 | 值 |
+|---|---:|
+| base | `unsloth/Qwen3-VL-4B-Instruct@252d592...` |
+| frames per pair | A 8 + B 8 |
+| canvas | 256×256 letterbox |
+| LoRA | r=8, alpha=16, dropout=0.05 |
+| LoRA targets | q/k/v/o projections |
+| trainable | LoRA + 5 special-token rows + 3 heads |
+| trainable params | 15,768,332 |
+| micro batch | 32 pairs |
+| gradient accumulation | 2 |
+| effective batch | 64 pairs |
+| precision | BF16 |
+| attention | FlashAttention 2 |
+| activation checkpointing | enabled |
+| optimizer | standard AdamW |
+| LoRA LR / heads LR | 2e-6 / 1e-4 |
+| weight decay | 0.01 |
+| scheduler | cosine, 5% warmup |
+| grad clip | 1.0 |
+| steps | 3,000 hard cap per seed；ID-dev early stop |
+| seeds | 7, 17, 27 |
+| checkpoint/eval | every 250 steps；min 1,000；patience 4；min delta 0.005 |
+
+新增 token 的顺序必须保持：
+
+```text
+<|split_token|>, <|reward_token|>, <|pref_token|>, <|sim_token|>, <|prog_token|>
+```
+
+在当前 base revision 上对应 ID 为 151669–151673。
+
+### 6.2 单步 smoke
+
+在新服务器上必须先跑最长 prompt pool 的真实一步：
+
+```bash
+cd "$PHASE21A_KIT"
+uv run --project environment/phase21a_robometer python scripts/smoke_phase21a_robometer_low.py \
+  --snapshot "$PHASE21A_MODEL" \
+  --manifest "$PHASE21A_DATA/manifests/phase2_remediation_pairs_v1.jsonl" \
+  --processed-root "$PHASE21A_DATA/processed_datasets" \
+  --micro-batch-pairs 32 \
+  --gradient-accumulation 2 \
+  --optimizer-steps 1 \
+  --pair-pool-size 8 \
+  --seed 7 \
+  --lora-lr 2e-6 \
+  --head-lr 1e-4 \
+  --output /tmp/phase21a_lora_smoke.json
+```
+
+通过条件：
+
+- `status=pass`；
+- effective batch 精确 64；
+- sequence max 不超过已知最长 1,319 tokens；
+- 三个 loss 有限；
+- LoRA、token rows、三个 heads 的梯度都有限且非零；
+- 峰值 reserved 不超过本机显存安全线。RTX 5090 参考值为 28.150 GiB，但其他 GPU 不应机械套用。
+
+### 6.3 正式启动
+
+portable runner 已支持显式模型、manifest 和数据路径：
+
+```bash
+cd "$PHASE21A_KIT"
+uv run --project environment/phase21a_robometer python scripts/run_phase21a_robometer_low_lora_seeds.py \
+  --snapshot "$PHASE21A_MODEL" \
+  --manifest "$PHASE21A_DATA/manifests/phase2_remediation_pairs_v1.jsonl" \
+  --processed-root "$PHASE21A_DATA/processed_datasets" \
+  --output-root "$PHASE21A_RUNS/robometer-low-lora-v2" \
+  --seeds 7 17 27 \
+  --optimizer-steps 3000 \
+  --micro-batch-pairs 32 \
+  --gradient-accumulation 2 \
+  --lora-lr 2e-6 \
+  --head-lr 1e-4 \
+  --checkpoint-every 250 \
+  --eval-every 250 \
+  --early-stop-min-steps 1000 \
+  --early-stop-patience-evals 4 \
+  --early-stop-min-delta 0.005
+```
+
+生产服务器上应由 Slurm、systemd 或其他作业调度器托管；不要依赖普通 SSH shell 的 `&`。每次只运行
+一个 runner，避免两个进程写同一 output root。
+
+### 6.4 恢复
+
+runner 会检测每个 seed 的：
+
+- 有 `summary.json`：跳过已完成 seed；
+- 有 `latest_training_state.pt`：自动加 `--resume`；
+- 两者都没有：从 step 0 开始。
+
+完整 checkpoint 包含 adapter、heads、AdamW、scheduler、NumPy/PyTorch/CUDA RNG、数据 permutation
+和 cursor。恢复前不得修改 manifest；trainer 会核对 manifest SHA256 和 seed。
+
+### 6.5 监控
+
+```bash
+tail -f "$PHASE21A_RUNS/robometer-low-lora-v2/seed_7/progress.jsonl"
+nvidia-smi
+```
+
+每条 progress record 应包含三个 loss、全局和分组梯度、LR、序列长度、step time 和显存。立即停止的
+异常包括：NaN/Inf、任一必要梯度组为零、manifest hash 改变、frame file 缺失或 OOM。
+
+RTX 5090 当前参考吞吐约 23–24 秒/step、2.7 pairs/s；硬件和温控会改变 ETA。
+
+### 6.6 完成产物
+
+每个 seed 完成后应出现：
+
+```text
+seed_<n>/
+├── adapter/
+├── reward_heads.pt
+├── best_model_state.pt
+├── latest_training_state.pt
+├── progress.jsonl
+├── id_dev_metrics.jsonl
+└── summary.json
+```
+
+发布前另外保存 processor/tokenizer 和特殊 token map；对外权重优先使用 safetensors。v2 的
+`adapter/` 和 `reward_heads.pt` 会恢复为 ID-dev 最佳 step，而不是机械使用最后一步。
+
+## 7. Robometer-Low 全量 decoder 训练
+
+### 7.1 当前禁止直接正式启动
+
+单张 RTX 5090 上，标准 AdamW 即使 `micro_batch_pairs=1` 也在第一次 optimizer-state 初始化时 OOM。
+PagedAdamW8bit 虽能跑通容量 smoke，但用户已明确禁止其用于正式 Robometer-Low。
+
+当前 `smoke_phase21a_robometer_low_full.py` 只是容量和梯度审计工具，不具备：
+
+- 多 GPU/FSDP；
+- 正式 3,000-step cap 和 ID-dev 早停的可恢复状态；
+- distributed RNG/data cursor 恢复；
+- sharded optimizer checkpoint；
+- 三 seed runner。
+
+因此在正式 full runner 实现并通过下述门禁前，Robometer-Low 状态保持
+`waiting_for_server_resources`，不能把 smoke 循环延长后冒充正式训练。
+
+### 7.2 目标正式配置
+
+| 参数 | 目标值 |
+|---|---:|
+| vision encoder | frozen |
+| language decoder | full trainable，`use_peft=false` |
+| heads | full trainable |
+| language trainable params | 约 4.0218B |
+| heads trainable params | 9.857M |
+| optimizer | standard torch AdamW，禁止 bitsandbytes/paged |
+| LR | 2e-5 |
+| weight decay | 0.01 |
+| precision/attention | BF16 / FlashAttention 2 |
+| activation checkpointing | enabled |
+| scheduler | cosine，5% warmup |
+| grad clip | 10.0（与当前 full smoke/官方设置一致） |
+| global effective batch | 至少且优先精确为 64 pairs |
+| steps/seeds | 3,000 hard cap + 与 LoRA 相同 ID-dev 早停；7/17/27 |
+
+分布式 global batch 计算公式：
+
+```text
+global_effective_batch = micro_batch_pairs_per_gpu × world_size × gradient_accumulation
+```
+
+例如 4 GPU、每卡 micro batch 8、accumulation 2 得到 64；这只是算术示例，必须以目标硬件 capacity
+smoke 为准。
+
+### 7.3 正式 runner 的实现门禁
+
+正式代码必须满足：
+
+1. 复用 LoRA v1 的 portable manifest loader、联合 A/B prompt、五 token 顺序和三 heads；
+2. 只冻结视觉塔，语言 decoder 全量 `requires_grad=True`；
+3. optimizer 类型审计精确为 `torch.optim.AdamW`，代码路径不导入 bitsandbytes；
+4. FSDP `FULL_SHARD` 包裹 `Qwen3VLTextDecoderLayer`，并验证无未分片的巨型语言层；
+5. global effective batch 精确记录并达到 64；
+6. 每 rank 数据不重复，分布式 sampler 的 epoch/order/cursor 可恢复；
+7. checkpoint 包含模型、heads、optimizer、scheduler、scaler（如有）、全部 RNG 和 sampler state；
+8. 中间 checkpoint 优先 sharded state，最终再受控合并，避免 rank 0 保存时 OOM；
+9. rank 0 写日志，所有 rank 对 NaN/OOM/数据异常做同步失败；
+10. OOD 不进入训练或选择。
+
+上游 Robometer 的 `robometer/configs/distributed/fsdp.yaml` 可作为 FSDP 配置参考，但官方
+`train.py` 不能直接替代本实验 runner：其默认 PEFT 为 r=32 且覆盖 MLP projections，数据采样和当前
+冻结 manifest 也不同。直接运行官方命令会形成另一个 protocol。
+
+### 7.4 服务器验收顺序
+
+1. 在隔离进程中加载模型，确认视觉 trainable=0、语言和 heads 数量正确；
+2. 用最长 prompt 跑一次 FSDP forward/backward/标准 AdamW step；
+3. 尝试相邻 micro batches，选择峰值显存不超过 90% 的最大安全值；
+4. 通过 accumulation 调整 global effective batch 到 64；
+5. 跑 100-step stability smoke，要求 0 NaN/Inf、0 OOM、0 empty mask；
+6. 在 step 50 保存，重启后恢复到 51，并与不中断参考运行核对 loss/LR/data cursor；
+7. 固定代码 commit、FSDP config hash、world size 和环境后，才允许三 seed 正式启动。
+
+### 7.5 多 GPU checkpoint 和发布
+
+- 训练 checkpoint 保留 sharded optimizer state，供相同或兼容 world size 恢复。
+- 发布 checkpoint 只在训练结束后合并；合并节点要有足够 CPU RAM 和磁盘临时空间。
+- 模型卡必须注明 base revision、数据 commit、world size、global batch、FSDP strategy 和标准 AdamW。
+- 任何使用 8-bit/paged optimizer 的结果必须另命名为实验性分支，不能称为 Robometer-Low。
+
+## 8. 最终开跑检查表
+
+### LoRA
+
+- [ ] kit/data/model 三个 commit/revision 已固定
+- [ ] SHA256 全通过，4,323/4,323 frame files 可解析
+- [ ] 单步 smoke 通过且显存安全
+- [ ] output root 全新或只有可信完整 checkpoint
+- [ ] 作业调度器托管，只有一个 runner
+- [ ] seeds 7/17/27、3,000-step cap、ID-dev 早停、effective batch 64
+- [ ] OOD 未接入训练 loop
+
+### Full
+
+- [ ] 服务器资源已分配
+- [ ] 自定义正式 FSDP runner 已实现和 code review
+- [ ] standard AdamW 类型审计通过，代码不走 bitsandbytes
+- [ ] 100-step 和断点恢复一致性门禁通过
+- [ ] global effective batch=64
+- [ ] vision frozen、language full trainable
+- [ ] 中间 sharded checkpoint 与最终合并流程均验证
+- [ ] 完成上述全部条件后才从 `waiting_for_server_resources` 改为 `running`

configs/phase21a_robometer_low_full_smoke_v1.yaml

@@ -0,0 +1,58 @@
+protocol_id: phase21a_robometer_low_full_smoke_v1
+status: smoke_only
+formal_training_allowed: false
+cosmos3_edge_modification_allowed: false
+
+naming:
+  robometer_low: full_language_decoder_tuning_on_non_full_public_proxy_data
+  robometer_low_lora: attention_lora_on_non_full_public_proxy_data
+  low_meaning: dataset_scale_not_parameter_tuning_method
+
+data:
+  route: Public-Proxy stage2_core_v1
+  manifest: manifests/phase2_remediation_pairs_v1.jsonl
+  split: train
+  frames_per_trajectory: 8
+  joint_frames_per_pair: 16
+  canvas: [256, 256]
+  smoke_pair_pool: 8
+  smoke_pair_pool_selection: longest_prompt_characters_in_train_split
+
+architecture:
+  base: Qwen3-VL-4B-Instruct
+  vision_frozen: true
+  language_decoder_full_tune: true
+  peft_or_lora: false
+  new_special_token_rows_trainable: true
+  heads_trainable: [progress, success, preference]
+  joint_trajectory_a_b_forward: true
+  per_frame_progress_token: <|prog_token|>
+  pair_preference_token: <|pref_token|>
+  progress_bins: 10
+
+optimization:
+  precision: BF16
+  attention: flash_attention_2
+  gradient_checkpointing: true
+  learning_rate: 2.0e-5
+  weight_decay: 0.01
+  gradient_clip: 10.0
+  minimum_effective_batch_pairs: 64
+  optimizer_trials:
+    - name: adamw_torch
+      official_default: true
+      foreach: false
+    - name: paged_adamw_8bit
+      official_default: false
+      purpose: single_gpu_full_parameter_fallback_if_adamw_state_oom
+
+capacity_selection:
+  each_candidate_in_fresh_process: true
+  memory_headroom_rule: peak_reserved_fraction_lte_0.90
+  final_gradient_accumulation: ceil(64 / selected_micro_batch_pairs)
+  final_validation_optimizer_steps: 1
+
+outputs:
+  root: runs/phase21a_robometer_low_full_smoke_v1
+  report_json: reports/phase21a_robometer_low_full_smoke_v1.json
+  report_markdown: reports/PHASE21A_ROBOMETER_LOW_FULL_SMOKE_V1.md

configs/phase21a_robometer_low_lora_train_v2.yaml

@@ -0,0 +1,88 @@
+protocol_id: phase21a_robometer_low_lora_train_v2
+status: configured_not_started
+model_name: Robometer-Low-LoRA
+low_meaning: non_full_public_proxy_dataset
+
+data:
+  route: Public-Proxy stage2_core_v1
+  manifest: manifests/phase2_remediation_pairs_v1.jsonl
+  train_pairs: 2021
+  id_dev_pairs: 108
+  confirmation_dev_pairs: 538
+  frames_per_trajectory: 8
+  joint_frames_per_pair: 16
+  canvas: [256, 256]
+
+architecture:
+  base: Qwen3-VL-4B-Instruct
+  base_revision: 252d592b59b0233b226875a44ac135cfa1d3f755
+  vision_frozen: true
+  language_base_frozen: true
+  language_lora:
+    rank: 8
+    alpha: 16
+    dropout: 0.05
+    targets: [q_proj, k_proj, v_proj, o_proj]
+  special_token_rows_trainable: true
+  heads_trainable: [progress, success, preference]
+
+training:
+  seeds: [7, 17, 27]
+  optimizer_steps_cap_per_seed: 3000
+  pair_presentations_at_cap: 192000
+  nominal_epochs_at_cap: 95.0025
+  micro_batch_pairs: 32
+  gradient_accumulation: 2
+  effective_batch_pairs: 64
+  precision: BF16
+  gradient_checkpointing: true
+  attention: flash_attention_2
+  optimizer: AdamW
+  lora_lr: 2.0e-6
+  head_lr: 1.0e-4
+  weight_decay: 0.01
+  scheduler: cosine
+  warmup_fraction: 0.05
+  warmup_steps_at_cap: 150
+  gradient_clip: 1.0
+  checkpoint_every_steps: 250
+
+model_selection:
+  split: dev
+  uses_confirmation_dev: false
+  uses_ood: false
+  evaluate_every_steps: 250
+  evaluate_both_pair_orientations: true
+  eval_micro_batch_pairs: 32
+  metric: summed_mean_id_dev_loss
+  mode: min
+  minimum_training_steps: 1000
+  patience_evaluations: 4
+  minimum_delta: 0.005
+  restore_best_checkpoint: true
+
+budget_basis:
+  official_rbm_1m_steps: 15000
+  official_scale_interpretation: approximately_960000_presentations_at_effective_batch_64
+  low_dataset_interpretation_of_15000: approximately_475_nominal_epochs
+  v2_cap_interpretation: approximately_95_nominal_epochs
+  phase20a_reference_steps: 2000
+  decision: use_3000_as_a_hard_cap_and_select_or_stop_on_id_dev
+
+robometer_low_full:
+  status: waiting_for_server_resources
+  optimizer_steps_cap_per_seed: 3000
+  model_selection: same_as_lora_for_matched_comparison
+  required_optimizer: official_adamw
+  paged_adamw_8bit_formal_training_allowed: false
+
+environment:
+  project: environment/phase21a_robometer
+  lockfile: environment/phase21a_robometer/uv.lock
+
+outputs:
+  root: runs/phase21a_robometer_low_lora_train_v2
+  progress_log_name: progress.jsonl
+  id_dev_log_name: id_dev_metrics.jsonl
+  checkpoint_name: latest_training_state.pt
+  best_model_name: best_model_state.pt

configs/phase21a_robometer_low_smoke_v1.yaml

@@ -0,0 +1,83 @@
+protocol_id: phase21a_robometer_low_lora_smoke_v1
+status: smoke_only
+formal_training_allowed: false
+cosmos3_edge_modification_allowed: false
+
+scope:
+  phase: Phase 2.1A
+  model: Robometer-Low-LoRA
+  purpose: select_a_stable_gpu_saturating_micro_batch_before_formal_training
+
+data:
+  route: Public-Proxy stage2_core_v1
+  manifest: manifests/phase2_remediation_pairs_v1.jsonl
+  split: train
+  real_pairs: true
+  frames_per_trajectory: 8
+  trajectories_per_pair: 2
+  canvas: [256, 256]
+  smoke_pair_pool: 8
+  smoke_pair_pool_selection: longest_prompt_characters_in_train_split
+
+architecture:
+  base: Qwen3-VL-4B-Instruct
+  robometer_contract:
+    joint_trajectory_a_b_forward: true
+    per_frame_progress_token: <|prog_token|>
+    pair_preference_token: <|pref_token|>
+    split_token: <|split_token|>
+    progress_head: discrete_10_bin
+    success_head: binary
+    preference_head: direct_binary
+    head_topology: linear_half_layernorm_gelu_dropout_linear
+    preference_order_randomization: deterministic_alternation_for_smoke
+  low_resource_delta:
+    vision_frozen: true
+    language_lora:
+      rank: 8
+      alpha: 16
+      dropout: 0.05
+      targets: [q_proj, k_proj, v_proj, o_proj]
+    newly_added_special_token_rows_trainable: true
+    heads_trainable: [progress, success, preference]
+    full_language_model_training: false
+
+optimization:
+  precision: BF16
+  attention: flash_attention_2
+  gradient_checkpointing: true
+  optimizer: AdamW
+  head_lr: 1.0e-4
+  lora_and_token_lr: 2.0e-6
+  weight_decay: 0.01
+  gradient_clip: 1.0
+  minimum_effective_batch_pairs: 64
+
+capacity_selection:
+  candidates_micro_batch_pairs_tested: [1, 2, 3, 4, 6, 8, 16, 24, 32, 34, 35]
+  adaptive_expansion_reason: micro_batch_8_used_only_41_56_percent_peak_reserved
+  each_candidate_in_fresh_process: true
+  capacity_probe_optimizer_steps: 1
+  stable_requires:
+    - finite_total_and_component_losses
+    - finite_trainable_gradients
+    - all_three_heads_receive_gradients
+    - lora_receives_gradients
+    - special_token_rows_receive_gradients
+    - no_oom
+  memory_headroom_rule: peak_reserved_fraction_lte_0.90
+  selected_micro_batch_pairs: 32
+  selected_gradient_accumulation: 2
+  selected_effective_batch_pairs: 64
+  selection_override: user_confirmed_2026_08_27
+  rejected_adjacent_setting:
+    micro_batch_pairs: 33
+    gradient_accumulation: 2
+    reason: user_selected_micro_batch_32_for_exact_effective_batch_64
+  final_validation_optimizer_steps: 1
+
+outputs:
+  filename_compatibility_note: legacy_paths_retain_robometer_low_prefix
+  root: runs/phase21a_robometer_low_smoke_v1
+  report_json: reports/phase21a_robometer_low_smoke_v1.json
+  report_markdown: reports/PHASE21A_ROBOMETER_LOW_SMOKE_V1.md

environment/phase21a_robometer/.python-version

@@ -0,0 +1 @@
+3.10.12

environment/phase21a_robometer/README.md

@@ -0,0 +1,36 @@
+# Phase 2.1A uv environment
+
+This directory is the deployable Python environment definition for
+`Robometer-Low-LoRA` and `Robometer-Low`. Do not copy a local `.venv` between
+machines.
+
+## Host requirements
+
+- Linux x86_64
+- NVIDIA GPU with BF16 support
+- NVIDIA driver compatible with CUDA 12.8
+- `uv` 0.11.3 or a compatible newer release
+- A CUDA development toolkit is needed only if no compatible prebuilt
+  FlashAttention wheel can be selected and a source build is required.
+
+## Rebuild
+
+From the experiment root:
+
+```bash
+uv python install 3.10.12
+uv sync --project environment/phase21a_robometer --frozen
+uv run --project environment/phase21a_robometer python environment/phase21a_robometer/doctor.py
+```
+
+The second `uv sync --frozen --dry-run` must report no changes. Run the formal
+training smoke test before starting a seed.
+
+The formal trainer sets `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True` before
+initializing CUDA. Keep this setting for the validated micro-batch of 32 pairs;
+removing it can cause allocator-fragmentation OOM near the RTX 5090 capacity
+limit even when several GiB are reserved but unused.
+
+The base model, public-proxy dataset, and run output are external artifacts and
+must not be placed inside this environment directory. Pin their Hugging Face
+revisions in the run manifest.

environment/phase21a_robometer/doctor.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Fail fast when a Phase 2.1A deployment cannot run the frozen trainer."""
+
+from __future__ import annotations
+
+import importlib.metadata as metadata
+import json
+import platform
+import sys
+
+import torch
+
+
+EXPECTED = {
+    "accelerate": "1.14.0",
+    "bitsandbytes": "0.49.2",
+    "flash-attn": "2.8.3.post1",
+    "numpy": "1.26.4",
+    "peft": "0.19.1",
+    "torch": "2.8.0",
+    "torchvision": "0.23.0",
+    "transformers": "4.57.6",
+}
+
+
+def normalized(version: str) -> str:
+    return version.split("+", maxsplit=1)[0]
+
+
+def main() -> None:
+    actual = {name: metadata.version(name) for name in EXPECTED}
+    mismatches = {
+        name: {"expected": expected, "actual": actual[name]}
+        for name, expected in EXPECTED.items()
+        if normalized(actual[name]) != expected
+    }
+    if mismatches:
+        raise RuntimeError(f"package version mismatch: {mismatches}")
+    if sys.version_info[:2] != (3, 10):
+        raise RuntimeError(f"Python 3.10 is required, found {platform.python_version()}")
+    if not torch.cuda.is_available():
+        raise RuntimeError("CUDA is unavailable")
+    if torch.version.cuda != "12.8":
+        raise RuntimeError(f"PyTorch CUDA 12.8 is required, found {torch.version.cuda}")
+    if not torch.cuda.is_bf16_supported():
+        raise RuntimeError("GPU does not support BF16")
+
+    import flash_attn
+    from flash_attn import flash_attn_func
+
+    device = torch.device("cuda:0")
+    query = torch.randn(1, 16, 2, 64, device=device, dtype=torch.bfloat16)
+    key = torch.randn_like(query)
+    value = torch.randn_like(query)
+    output = flash_attn_func(query, key, value, causal=True)
+    if output.shape != query.shape or not torch.isfinite(output).all():
+        raise RuntimeError("FlashAttention CUDA probe failed")
+
+    print(
+        json.dumps(
+            {
+                "status": "pass",
+                "python": platform.python_version(),
+                "packages": actual,
+                "torch_cuda": torch.version.cuda,
+                "gpu": torch.cuda.get_device_name(0),
+                "compute_capability": torch.cuda.get_device_capability(0),
+                "bf16_supported": True,
+                "flash_attn": flash_attn.__version__,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

environment/phase21a_robometer/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "cosmos-robometer-phase21a"
+version = "0.1.0"
+description = "Reproducible runtime for Phase 2.1A Robometer-Low and Robometer-Low-LoRA"
+requires-python = "==3.10.*"
+dependencies = [
+    "accelerate==1.14.0",
+    "bitsandbytes==0.49.2",
+    "flash-attn==2.8.3.post1",
+    "hf-xet==1.5.1",
+    "huggingface-hub==0.36.2",
+    "numpy==1.26.4",
+    "peft==0.19.1",
+    "pillow==11.3.0",
+    "pyyaml==6.0.3",
+    "qwen-vl-utils==0.0.14",
+    "safetensors==0.8.0",
+    "torch==2.8.0",
+    "torchvision==0.23.0",
+    "transformers==4.57.6",
+]
+
+[tool.uv]
+package = false
+
+# flash-attn must build or select its wheel against the exact PyTorch runtime.
+[tool.uv.extra-build-dependencies]
+flash-attn = [{ requirement = "torch", match-runtime = true }]
+
+[tool.uv.extra-build-variables]
+flash-attn = { FLASH_ATTENTION_SKIP_CUDA_BUILD = "TRUE" }
+
+[tool.uv.sources]
+torch = { index = "pytorch-cu128", marker = "sys_platform == 'linux' or sys_platform == 'win32'" }
+torchvision = { index = "pytorch-cu128", marker = "sys_platform == 'linux' or sys_platform == 'win32'" }
+
+[[tool.uv.index]]
+name = "pytorch-cu128"
+url = "https://download.pytorch.org/whl/cu128"
+explicit = true

environment/phase21a_robometer/system-manifest.json

@@ -0,0 +1,37 @@
+{
+  "environment_id": "phase21a_robometer_uv_v1",
+  "generated_at": "2026-08-27T19:48:21+08:00",
+  "lock_sha256": "69d9354b3197aa9e7d3b649c8cab76beb50f685bee96e28e7ad55e72421a3b8d",
+  "uv_version_used_to_lock": "0.11.3",
+  "python": "3.10.12",
+  "platform": "linux_x86_64",
+  "pytorch": "2.8.0+cu128",
+  "torch_cuda": "12.8",
+  "flash_attn": "2.8.3.post1",
+  "reference_host": {
+    "os": "Ubuntu 22.04",
+    "gpu": "NVIDIA GeForce RTX 5090",
+    "gpu_memory_mib": 32607,
+    "compute_capability": "12.0",
+    "nvidia_driver": "580.173.02"
+  },
+  "target_requirements": {
+    "bf16": true,
+    "nvidia_driver_compatible_with_cuda_12_8": true,
+    "flash_attention_cuda_probe_required": true
+  },
+  "video_decode_dependency": "not_installed_multi_image_training_only",
+  "base_model": {
+    "repo_id": "unsloth/Qwen3-VL-4B-Instruct",
+    "revision": "252d592b59b0233b226875a44ac135cfa1d3f755"
+  },
+  "robometer_upstream_revision": "a669dffc241d7d76bec12f36efd4084d914d017c",
+  "verification": {
+    "clean_uv_sync": "pass",
+    "second_frozen_sync_no_changes": "pass",
+    "uv_pip_check": "pass",
+    "bf16_flash_attention_doctor": "pass",
+    "phase21a_v2_one_step_and_full_id_dev_smoke": "pass",
+    "smoke_peak_reserved_gib": 27.193359375
+  }
+}

environment/phase21a_robometer/uv.lock

@@ -0,0 +1,814 @@
+version = 1
+revision = 3
+requires-python = "==3.10.*"
+resolution-markers = [
+    "sys_platform == 'linux' or sys_platform == 'win32'",
+    "sys_platform != 'linux' and sys_platform != 'win32'",
+]
+
+[[package]]
+name = "accelerate"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyyaml" },
+    { name = "safetensors" },
+    { name = "torch", version = "2.8.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torch", version = "2.8.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8d/75/94cd5d389649578aca399e5aa822637eec18319a1dadc400ffe2f9a7493f/accelerate-1.14.0.tar.gz", hash = "sha256:41b9c4377a54e0b460a959b0defa1b736e4ca0a2373252d9a539964c2afe3c8d", size = 412167, upload-time = "2026-06-11T13:45:52.326Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/db/253133d7e7cb40d3af384bb2f5c0b4a2b7fdcffbc95c688cc67a20a3c103/accelerate-1.14.0-py3-none-any.whl", hash = "sha256:e94390c2863b873be18f623f9df48a0d8fe5eff13ea7f1a00092b0a7904888c6", size = 389246, upload-time = "2026-06-11T13:45:50.477Z" },
+]
+
+[[package]]
+name = "av"
+version = "17.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/e3/477fa20578c284abeda08d91b63ee9abaebc93445d8feeb989d3d444bae1/av-17.1.0.tar.gz", hash = "sha256:7f1e71ff621b66253333926f948e00faae11d855b2442133c65128bca64cdeb3", size = 4288546, upload-time = "2026-06-07T05:52:55.999Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/92/c9d0cea4f6f8f93f5b15a39f99d2d593f922484f22a2d98a8d482283e15b/av-17.1.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:19c84fd72af5ef81a20f18fbc6f9aedff9e1455e53a7062c1d4c95926d73da4e", size = 22622703, upload-time = "2026-06-07T05:51:40.405Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/57/74399770aa103ee4b5ff6da1781440c91a41901d89abb2433fe88773246e/av-17.1.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:19264c9bb4bee404accc7ce9ec461f2044b7f577a70234d29aafde31ed17de46", size = 18273538, upload-time = "2026-06-07T05:51:43.078Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/17/27c85b12e9ffa8f3f6854358b3eabcd91f3c29c7dac36843fa1376e833f4/av-17.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:22dff0ae582d10ef08c75c2150a4fd27cfc26653b54930c7c27b9f7b3aa20723", size = 34519101, upload-time = "2026-06-07T05:51:45.305Z" },
+    { url = "https://files.pythonhosted.org/packages/04/a4/542d4bfd9f4aec5f3265985b9dbc6b259d45c2e668f9714e5f4e05b71e64/av-17.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:90c49bc9608377d01e82e747377505419a229464873341db18202d5dddecce5a", size = 36647600, upload-time = "2026-06-07T05:51:48.57Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1e/63bd5c59580f38109fa4c452b29b715a20c9a5eb3a078b3c447484593c40/av-17.1.0-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:cc5a5247622cb77e24c342364eb68f88c1442ddfaab60c1f1f483359d3cc7879", size = 25786289, upload-time = "2026-06-07T05:51:51.674Z" },
+    { url = "https://files.pythonhosted.org/packages/70/30/78155cef0c9f8bc13f044130192c58bf962f2c9066982ff3593afe8d27f1/av-17.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ff457ed419348e5b8e8c811d341389b052c5e4d5839da3794d019b125b9fe830", size = 35599848, upload-time = "2026-06-07T05:51:54.207Z" },
+    { url = "https://files.pythonhosted.org/packages/76/cb/ae1d7a735a5ad9dc502dba864c51d605cbe932a769218352fd570254c38e/av-17.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1370b11a697eb3f2555906f8ab3519b0cfe48425d7830a3996ad42e6bffafda5", size = 26776479, upload-time = "2026-06-07T05:51:56.788Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/40/128429b9eb0c4a2beb122ed8d04b189515df68967987c2654a2e262a5c43/av-17.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3dcd41e53f53f9a3260751d9c3c11d34e93d70d61e506c81f13dbc1e3606e07b", size = 37763744, upload-time = "2026-06-07T05:51:59.222Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6a/5980e7bbeeadfd7a9db8e38e9f1140a3e0c392fccc31bd7b1e4a75cf5a96/av-17.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:3453b06075c7bb973fdb6de52563f7692ff05cbc64c0bb45f4fd6e8709131f2f", size = 28126516, upload-time = "2026-06-07T05:52:01.658Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/87/8036b5c781bc3639ea04ef42d4e26da253bd4bd4311d8705b6a1c8824047/av-17.1.0-cp311-abi3-macosx_11_0_x86_64.whl", hash = "sha256:ad7b4aa011093324b7118245f50ac6db244cfe9900d4072508a5245a2b0d3f41", size = 22460847, upload-time = "2026-06-07T05:52:04.261Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/af/dfdf6fc7b17814b50d0aa9e7a7e37b87be91be3890f44b0d525433cd1fd1/av-17.1.0-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:43ebbe977f19a7f2d2bd1a4e119675a0b15e05852cf7309846b6ab922ba7ffe9", size = 18159115, upload-time = "2026-06-07T05:52:06.64Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/13/64f6c466471cea225b8b2f4cdc51a571f8a286984b55a08d169b932fda5d/av-17.1.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6a20658ec7d96a70e14b1196eff00b7cdd8831ac3b99868e16b8ba8b24090847", size = 33224427, upload-time = "2026-06-07T05:52:09.165Z" },
+    { url = "https://files.pythonhosted.org/packages/77/43/96b35170bf2e64e00a41748c6400ff73232dc0fc62ded283679fb07c7fe0/av-17.1.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f9a65d1f48b818323fb411e80358f89d77dec340b01d27c6b2dfbb9cbf4b779f", size = 35370183, upload-time = "2026-06-07T05:52:11.959Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b3/8e8b4b6498731bfbd88e8399a756543f8088f1bd33d08eab678b5aebe728/av-17.1.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:58f7593726437cda5bd19793027e027768450b5c4a594777bf487798a33db702", size = 24459265, upload-time = "2026-06-07T05:52:14.66Z" },
+    { url = "https://files.pythonhosted.org/packages/14/ac/ceb84b7553db21f1143d817245c560d9267168e1e58b1a8eeae2b62c4d04/av-17.1.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:bbab058bd965309f39962e53caac8126987c68c0be094fc4f9427e5615b0218f", size = 34283709, upload-time = "2026-06-07T05:52:17.389Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f9/4115fd84148c9a1cf365096694be6ac882fd3cd3cdb7a2f35e71fecf1631/av-17.1.0-cp311-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:9514cfda85180554c430695282faf4be3ffdf95775d8519733821244eecb58e0", size = 25397573, upload-time = "2026-06-07T05:52:20.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/ac/92e52d5ed0e0b84d9d93e52b4338c2713d8a44082b8696e6516fdae7c4e4/av-17.1.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e1c90f85cd7431ede95b11e8e711571a896ebea433f298849c2c0f1594c8d86e", size = 36451495, upload-time = "2026-06-07T05:52:22.581Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f2/53a7cd34adb6a971d7e6d99663e74db286966c9db8afdca17472fdf0f98e/av-17.1.0-cp311-abi3-win_amd64.whl", hash = "sha256:5df5c1172ef1cf65a1529d612f7da7798ce2cf82c1ff7212466b538a6cc7214c", size = 28036393, upload-time = "2026-06-07T05:52:25.657Z" },
+    { url = "https://files.pythonhosted.org/packages/66/47/cd9ae0edf2206351c1251bb94b5ec58728e42c5f6ee16c03c412f3a1bb3e/av-17.1.0-cp311-abi3-win_arm64.whl", hash = "sha256:ee98534242a74da847af78624779ac5a3177dc7c69f956a4da9e6f0fdb37d7f6", size = 21174601, upload-time = "2026-06-07T05:52:28.077Z" },
+]
+
+[[package]]
+name = "bitsandbytes"
+version = "0.49.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "torch", version = "2.8.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torch", version = "2.8.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/7d/f1fe0992334b18cd8494f89aeec1dcc674635584fcd9f115784fea3a1d05/bitsandbytes-0.49.2-py3-none-macosx_14_0_arm64.whl", hash = "sha256:87be5975edeac5396d699ecbc39dfc47cf2c026daaf2d5852a94368611a6823f", size = 131940, upload-time = "2026-02-16T21:26:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/29/71/acff7af06c818664aa87ff73e17a52c7788ad746b72aea09d3cb8e424348/bitsandbytes-0.49.2-py3-none-manylinux_2_24_aarch64.whl", hash = "sha256:2fc0830c5f7169be36e60e11f2be067c8f812dfcb829801a8703735842450750", size = 31442815, upload-time = "2026-02-16T21:26:06.783Z" },
+    { url = "https://files.pythonhosted.org/packages/19/57/3443d6f183436fbdaf5000aac332c4d5ddb056665d459244a5608e98ae92/bitsandbytes-0.49.2-py3-none-manylinux_2_24_x86_64.whl", hash = "sha256:54b771f06e1a3c73af5c7f16ccf0fc23a846052813d4b008d10cb6e017dd1c8c", size = 60651714, upload-time = "2026-02-16T21:26:11.579Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d4/501655842ad6771fb077f576d78cbedb5445d15b1c3c91343ed58ca46f0e/bitsandbytes-0.49.2-py3-none-win_amd64.whl", hash = "sha256:2e0ddd09cd778155388023cbe81f00afbb7c000c214caef3ce83386e7144df7d", size = 55372289, upload-time = "2026-02-16T21:26:16.267Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.7.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/aa/554e2614f38fc34c58ff1d0911ae8535ad2516440d5482d76fe59f1088b0/charset_normalizer-3.5.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1ee1e296209fdce05b81b663250eefa02213a2da7b41bf26f7829b8ba3545aa", size = 369072, upload-time = "2026-08-15T08:16:22.964Z" },
+    { url = "https://files.pythonhosted.org/packages/03/6d/439231dfc3ccfa6f8c06477b7da2219cbd41a2de3d49084df8ec7b5100f2/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9fbdce1e47394b09bc9f26ab117dfc8d6491977a11d86f592bb42c779db2fda", size = 251142, upload-time = "2026-08-15T08:16:24.81Z" },
+    { url = "https://files.pythonhosted.org/packages/55/53/7d819bd23a00ef45039146fa2cce1daa2f0771e758c5653ee1f6edac91ed/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00668ebb0609751758682eb0b5857e7c35b9f00e84dfdef062e103244ec94d45", size = 240714, upload-time = "2026-08-15T08:16:26.392Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2c/45847198c16f4b38090cc7423b2b6a9008e438704d8ab413211832498d31/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba2f37ee79e6338845261a3c5b1784e5d1acdff2c0785b284f1b633033d136ab", size = 279637, upload-time = "2026-08-15T08:16:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/69/2b/d8be3523ddf9f0b0f3e56d1359034aa10653a4d11564c697f802b4775766/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ce854f5f478050ade5a238731c4ca985a7d3b3cb53ff600a9b5c3b689b5f0a7a", size = 276543, upload-time = "2026-08-15T08:16:29.399Z" },
+    { url = "https://files.pythonhosted.org/packages/32/cd/4f564b8f132de25db594efc706897069f016790cea63a5669c9df2675f64/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96eefc178f8636b9c760c5829345307fd81cfae9ab1e80997dbddeb0f54ee9a3", size = 261644, upload-time = "2026-08-15T08:16:30.722Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e3/38b975422534a608f98c360e79c2f07c763d66dd4272300d45fb1fee54b0/charset_normalizer-3.5.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:366ec70f5547c640d3ce1985722490f23faf4eb5216a7eeba78277490e78dacb", size = 259609, upload-time = "2026-08-15T08:16:32.248Z" },
+    { url = "https://files.pythonhosted.org/packages/87/bd/fbc24d825c66f1c74f6ccdea3742c3d8354a4888e86d1315a197fee69061/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:950f23cb393f85543777b0433f082cddd25b51ab398eac7971146495679efe5f", size = 252457, upload-time = "2026-08-15T08:16:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/2d/918d0e98a0e679469ed05bb2d90c2088b4d315bb612969d8499f76fb5210/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c1dcc36dcb96abc02236e182d17e0f71430152a6c2c7447421da2d2dc144edea", size = 242240, upload-time = "2026-08-15T08:16:35.396Z" },
+    { url = "https://files.pythonhosted.org/packages/20/c8/c36f6e0b2dfec351bd38cbc05362697e58bcd073d7dbd95154290c9714ce/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:07ffd07412fc5d5e84cd8952acf9ff7e4ed7a708e69d1bada19d8ba91711353f", size = 280308, upload-time = "2026-08-15T08:16:36.825Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/7b/311b3e02e8c4092400c449c850a760d8c45d900983c83a70cc07208c551d/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f5542f9b941279d82d41eb0aa9f98eba36fe4df5c7086c651df7944935b37182", size = 258679, upload-time = "2026-08-15T08:16:38.22Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/90/082cc45599c392f28c036a497f49e0634041a785fc3849c80ccf396d096f/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a545775cfe815855ea32d7c27731d79da358ef2055b4a25830231b1622dd18aa", size = 277221, upload-time = "2026-08-15T08:16:39.62Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ad/b9aecf38d805cbcf84fa94f14c5d972a16561e20296a11dc799a5dcf3763/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:494b70049a4d69aec6e8137c13af4cf8db8c9f9820a1392ac293b0dd2987a818", size = 263799, upload-time = "2026-08-15T08:16:40.885Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/23/b38a20598d5a825f85d9d7636860e56ff0db1479f86497a6e485aa9326f7/charset_normalizer-3.5.1-cp310-cp310-win32.whl", hash = "sha256:94fbf1c0c6cc0d3d5e50f9a9313a8cdca90dd696d34b381cd1704f8c9e939f20", size = 182037, upload-time = "2026-08-15T08:16:42.198Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/21/83fffb77864408b8bf0fe1ca603926401d6f8775a8e150b39aacc9958f8a/charset_normalizer-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:be47f99644b208bff7766314013f9acf57b056b04191d570d68ad14022cf5b1d", size = 206030, upload-time = "2026-08-15T08:16:43.787Z" },
+    { url = "https://files.pythonhosted.org/packages/86/2e/b93135b5034b1157fb29554b0d06d4844ce62282f0e0a14036f93d7ee2e7/charset_normalizer-3.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:a6d095662e73e74f0a49988e0593373e243e3a52e27bfeea0a859e88acf4a0f5", size = 185092, upload-time = "2026-08-15T08:16:45.177Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" },
+    { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" },
+    { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" },
+    { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" },
+    { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" },
+    { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "cosmos-robometer-phase21a"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "accelerate" },
+    { name = "bitsandbytes" },
+    { name = "flash-attn" },
+    { name = "hf-xet" },
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "peft" },
+    { name = "pillow" },
+    { name = "pyyaml" },
+    { name = "qwen-vl-utils" },
+    { name = "safetensors" },
+    { name = "torch", version = "2.8.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torch", version = "2.8.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "torchvision", version = "0.23.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torchvision", version = "0.23.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "transformers" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "accelerate", specifier = "==1.14.0" },
+    { name = "bitsandbytes", specifier = "==0.49.2" },
+    { name = "flash-attn", specifier = "==2.8.3.post1" },
+    { name = "hf-xet", specifier = "==1.5.1" },
+    { name = "huggingface-hub", specifier = "==0.36.2" },
+    { name = "numpy", specifier = "==1.26.4" },
+    { name = "peft", specifier = "==0.19.1" },
+    { name = "pillow", specifier = "==11.3.0" },
+    { name = "pyyaml", specifier = "==6.0.3" },
+    { name = "qwen-vl-utils", specifier = "==0.0.14" },
+    { name = "safetensors", specifier = "==0.8.0" },
+    { name = "torch", marker = "sys_platform != 'linux' and sys_platform != 'win32'", specifier = "==2.8.0" },
+    { name = "torch", marker = "sys_platform == 'linux' or sys_platform == 'win32'", specifier = "==2.8.0", index = "https://download.pytorch.org/whl/cu128" },
+    { name = "torchvision", marker = "sys_platform != 'linux' and sys_platform != 'win32'", specifier = "==0.23.0" },
+    { name = "torchvision", marker = "sys_platform == 'linux' or sys_platform == 'win32'", specifier = "==0.23.0", index = "https://download.pytorch.org/whl/cu128" },
+    { name = "transformers", specifier = "==4.57.6" },
+]
+
+[[package]]
+name = "einops"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.32.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/30/03b03951873a1a0ffc7e8ca0e10c15597b59e8d0e39260704cd2ea087bc4/filelock-3.32.4.tar.gz", hash = "sha256:2bde2e4cf732e0153406d8a7bc80620ecf5e621fe0d25e41143c4e3b4733ff30", size = 222126, upload-time = "2026-08-23T17:37:55.363Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/a4/9b63d595d748e3aff8812b65eacc1a2c4bd90b7c2012e08e72373b4835eb/filelock-3.32.4-py3-none-any.whl", hash = "sha256:22e58ca3b1ae3b98993b762d7338367ae64fe50252bf78d59da3bfebcdf1cedd", size = 99864, upload-time = "2026-08-23T17:37:53.913Z" },
+]
+
+[[package]]
+name = "flash-attn"
+version = "2.8.3.post1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "einops" },
+    { name = "torch", version = "2.8.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torch", version = "2.8.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/01/7a/92a46e7cd6bbb4d7b2855a457c3b855df54a97af5656d98fc92e58e61065/flash_attn-2.8.3.post1.tar.gz", hash = "sha256:55d5103ed846da8b56e0797acf4bde07dee4b1c7e8907fcfc6699c203030c348", size = 8451657, upload-time = "2026-06-11T04:35:21.318Z" }
+
+[[package]]
+name = "fsspec"
+version = "2026.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/00/78/f34251dadb8f3921264a1d9b8946f5e542014ee2614b285261b4e40e6775/fsspec-2026.7.0.tar.gz", hash = "sha256:c803c40f4cf860b49dea58ee3e1c33cb9c790520e233537e1340049f89b82a88", size = 317040, upload-time = "2026-07-28T16:34:51.052Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl", hash = "sha256:b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279", size = 206583, upload-time = "2026-07-28T16:34:49.538Z" },
+]
+
+[[package]]
+name = "hf-xet"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/2d/57fd21d84d93efb4bd0b962383790e19dd1bc053501b4264c97903b4e83e/hf_xet-1.5.1.tar.gz", hash = "sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6", size = 876636, upload-time = "2026-06-08T23:02:53.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/d8/5e54cf37434759d1f4f2ba9b66077ff9d4c4e1f37b6bd7975da5c40d94ab/hf_xet-1.5.1-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e", size = 4077794, upload-time = "2026-06-08T23:02:40.656Z" },
+    { url = "https://files.pythonhosted.org/packages/35/94/4b2ecfbad8f8b04701a23aefb62f540b9137d058b7e1dbef16a32676f0e9/hf_xet-1.5.1-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e", size = 3845354, upload-time = "2026-06-08T23:02:42.702Z" },
+    { url = "https://files.pythonhosted.org/packages/de/cc/f99f4bc7295023d7bd9ebbfd51f75cc530ca262c1227666268b8208f4b77/hf_xet-1.5.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350", size = 4514864, upload-time = "2026-06-08T23:02:44.497Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/6e/21f7e5a2381278bd3b7b7a5a4d90038518bb6308a0c1daf5d9f8268bb178/hf_xet-1.5.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4", size = 4303784, upload-time = "2026-06-08T23:02:46.203Z" },
+    { url = "https://files.pythonhosted.org/packages/35/0e/f992bb6927ac1cb30ef74e62268f551f338bc32b2191f7c96a44c6f7283e/hf_xet-1.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6", size = 4500703, upload-time = "2026-06-08T23:02:47.628Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d1/90a498d05447980b977b1669246eeeeae4cfb0ea3e7a286eaba627f91bf9/hf_xet-1.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf", size = 4719498, upload-time = "2026-06-08T23:02:49.268Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b6/20f99cfe97cc663a711f7b33cc21d4793e51968e9a26125b4afcd77315ba/hf_xet-1.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5", size = 4026419, upload-time = "2026-06-08T23:02:50.829Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/fa/77453694888f03e5a8c8852d1514a0894d8e81c622d39edbaf308ea0dcf4/hf_xet-1.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e", size = 3855178, upload-time = "2026-06-08T23:02:52.452Z" },
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "0.36.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", hash = "sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a", size = 649782, upload-time = "2026-02-06T09:24:13.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", hash = "sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270", size = 566395, upload-time = "2026-02-06T09:24:11.133Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+    { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+    { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+    { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+    { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "1.26.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/94/ace0fdea5241a27d13543ee117cbc65868e82213fb31a8eb7fe9ff23f313/numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0", size = 20631468, upload-time = "2024-02-05T23:48:01.194Z" },
+    { url = "https://files.pythonhosted.org/packages/20/f7/b24208eba89f9d1b58c1668bc6c8c4fd472b20c45573cb767f59d49fb0f6/numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a", size = 13966411, upload-time = "2024-02-05T23:48:29.038Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a5/4beee6488160798683eed5bdb7eead455892c3b4e1f78d79d8d3f3b084ac/numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4", size = 14219016, upload-time = "2024-02-05T23:48:54.098Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d7/ecf66c1cd12dc28b4040b15ab4d17b773b87fa9d29ca16125de01adb36cd/numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f", size = 18240889, upload-time = "2024-02-05T23:49:25.361Z" },
+    { url = "https://files.pythonhosted.org/packages/24/03/6f229fe3187546435c4f6f89f6d26c129d4f5bed40552899fcf1f0bf9e50/numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a", size = 13876746, upload-time = "2024-02-05T23:49:51.983Z" },
+    { url = "https://files.pythonhosted.org/packages/39/fe/39ada9b094f01f5a35486577c848fe274e374bbf8d8f472e1423a0bbd26d/numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2", size = 18078620, upload-time = "2024-02-05T23:50:22.515Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ef/6ad11d51197aad206a9ad2286dc1aac6a378059e06e8cf22cd08ed4f20dc/numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07", size = 5972659, upload-time = "2024-02-05T23:50:35.834Z" },
+    { url = "https://files.pythonhosted.org/packages/19/77/538f202862b9183f54108557bfda67e17603fc560c384559e769321c9d92/numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5", size = 15808905, upload-time = "2024-02-05T23:51:03.701Z" },
+]
+
+[[package]]
+name = "nvidia-cublas-cu12"
+version = "12.8.4.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc-cu12"
+version = "12.8.93"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu12"
+version = "9.10.2.21"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" },
+]
+
+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.3.3.83"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" },
+]
+
+[[package]]
+name = "nvidia-cufile-cu12"
+version = "1.13.1.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" },
+]
+
+[[package]]
+name = "nvidia-curand-cu12"
+version = "10.3.9.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver-cu12"
+version = "11.7.3.90"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cusparse-cu12", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse-cu12"
+version = "12.5.8.93"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu12"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu12"
+version = "2.27.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/5b/4e4fff7bad39adf89f735f2bc87248c81db71205b62bcc0d5ca5b606b3c3/nvidia_nccl_cu12-2.27.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adf27ccf4238253e0b826bce3ff5fa532d65fc42322c8bfdfaf28024c0fbe039", size = 322364134, upload-time = "2025-06-03T21:58:04.013Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink-cu12"
+version = "12.8.93"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" },
+]
+
+[[package]]
+name = "nvidia-nvtx-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "peft"
+version = "0.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "accelerate" },
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyyaml" },
+    { name = "safetensors" },
+    { name = "torch", version = "2.8.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torch", version = "2.8.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "tqdm" },
+    { name = "transformers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", hash = "sha256:0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40", size = 763738, upload-time = "2026-04-16T15:46:45.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", hash = "sha256:2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356", size = 680692, upload-time = "2026-04-16T15:46:42.886Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "11.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/5d/45a3553a253ac8763f3561371432a90bdbe6000fbdcf1397ffe502aa206c/pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860", size = 5316554, upload-time = "2025-07-01T09:13:39.342Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/c8/67c12ab069ef586a25a4a79ced553586748fad100c77c0ce59bb4983ac98/pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad", size = 4686548, upload-time = "2025-07-01T09:13:41.835Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/bd/6741ebd56263390b382ae4c5de02979af7f8bd9807346d068700dd6d5cf9/pillow-11.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0", size = 5859742, upload-time = "2025-07-03T13:09:47.439Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/0b/c412a9e27e1e6a829e6ab6c2dca52dd563efbedf4c9c6aa453d9a9b77359/pillow-11.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b", size = 7633087, upload-time = "2025-07-03T13:09:51.796Z" },
+    { url = "https://files.pythonhosted.org/packages/59/9d/9b7076aaf30f5dd17e5e5589b2d2f5a5d7e30ff67a171eb686e4eecc2adf/pillow-11.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50", size = 5963350, upload-time = "2025-07-01T09:13:43.865Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/16/1a6bf01fb622fb9cf5c91683823f073f053005c849b1f52ed613afcf8dae/pillow-11.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae", size = 6631840, upload-time = "2025-07-01T09:13:46.161Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e6/6ff7077077eb47fde78739e7d570bdcd7c10495666b6afcd23ab56b19a43/pillow-11.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9", size = 6074005, upload-time = "2025-07-01T09:13:47.829Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/3a/b13f36832ea6d279a697231658199e0a03cd87ef12048016bdcc84131601/pillow-11.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:040a5b691b0713e1f6cbe222e0f4f74cd233421e105850ae3b3c0ceda520f42e", size = 6708372, upload-time = "2025-07-01T09:13:52.145Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/e4/61b2e1a7528740efbc70b3d581f33937e38e98ef3d50b05007267a55bcb2/pillow-11.3.0-cp310-cp310-win32.whl", hash = "sha256:89bd777bc6624fe4115e9fac3352c79ed60f3bb18651420635f26e643e3dd1f6", size = 6277090, upload-time = "2025-07-01T09:13:53.915Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/d3/60c781c83a785d6afbd6a326ed4d759d141de43aa7365725cbcd65ce5e54/pillow-11.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:19d2ff547c75b8e3ff46f4d9ef969a06c30ab2d4263a9e287733aa8b2429ce8f", size = 6985988, upload-time = "2025-07-01T09:13:55.699Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/28/4f4a0203165eefb3763939c6789ba31013a2e90adffb456610f30f613850/pillow-11.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f", size = 2422899, upload-time = "2025-07-01T09:13:57.497Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8b/209bd6b62ce8367f47e68a218bffac88888fdf2c9fcf1ecadc6c3ec1ebc7/pillow-11.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967", size = 5270556, upload-time = "2025-07-01T09:16:09.961Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/e6/231a0b76070c2cfd9e260a7a5b504fb72da0a95279410fa7afd99d9751d6/pillow-11.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe", size = 4654625, upload-time = "2025-07-01T09:16:11.913Z" },
+    { url = "https://files.pythonhosted.org/packages/13/f4/10cf94fda33cb12765f2397fc285fa6d8eb9c29de7f3185165b702fc7386/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c", size = 4874207, upload-time = "2025-07-03T13:11:10.201Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c9/583821097dc691880c92892e8e2d41fe0a5a3d6021f4963371d2f6d57250/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25", size = 6583939, upload-time = "2025-07-03T13:11:15.68Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8e/5c9d410f9217b12320efc7c413e72693f48468979a013ad17fd690397b9a/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27", size = 4957166, upload-time = "2025-07-01T09:16:13.74Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bb/78347dbe13219991877ffb3a91bf09da8317fbfcd4b5f9140aeae020ad71/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a", size = 5581482, upload-time = "2025-07-01T09:16:16.107Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/28/1000353d5e61498aaeaaf7f1e4b49ddb05f2c6575f9d4f9f914a3538b6e1/pillow-11.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f", size = 6984596, upload-time = "2025-07-01T09:16:18.07Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+]
+
+[[package]]
+name = "qwen-vl-utils"
+version = "0.0.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "av" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/b1/ad4fc2260a3badd278b38d642f3b987412f1f6682f0ef2b31b0572d5caa8/qwen_vl_utils-0.0.14.tar.gz", hash = "sha256:9c7cad5ae803b3a10f8bb7194deb12aeacdd032f92f4224e880c73587a7346ad", size = 8453, upload-time = "2025-09-23T09:38:57.532Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/43/80f67e0336cb2fc725f8e06f7fe35c1d0fe946f4d2b8b2175e797e07349e/qwen_vl_utils-0.0.14-py3-none-any.whl", hash = "sha256:5e28657bfd031e56bd447c5901b58ddfc3835285ed100f4c56580e0ade054e96", size = 8120, upload-time = "2025-09-23T09:38:56.297Z" },
+]
+
+[[package]]
+name = "regex"
+version = "2026.7.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/98/04b13f1ddfb63158025291c02e03eb42fbb7acb51d091d541050eb4e35e8/regex-2026.7.19.tar.gz", hash = "sha256:7e77b324909c1617cbb4c668677e2c6ae13f44d7c1de0d4f15f2e3c10f3315b5", size = 416440, upload-time = "2026-07-19T00:19:48.923Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/13/bbf7d9d1887fe4a3693527c6caa232c197ea9da91f1212e9672eff60329d/regex-2026.7.19-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:555497390743af1a65045fa4527782d10ff5b88970359412baa4a1e628fe393b", size = 494009, upload-time = "2026-07-19T00:16:13.602Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/19/783688e75a2bec15d50aec0d5e7e317d363808bc82a6eb6750b897bfcd7b/regex-2026.7.19-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:343a4504e3fb688c47cad451221ca5d4814f42b1e16c0065bde9cbf7f473bd52", size = 295287, upload-time = "2026-07-19T00:16:15.702Z" },
+    { url = "https://files.pythonhosted.org/packages/16/01/cefe4f051302ca298d3f3e79ed6dbd933ac84485b9515acdd6a52d70cef7/regex-2026.7.19-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ebee1ee89c39c953baac6924fcde08c5bb427c4057510862f9d7c7bdb3d8665", size = 290633, upload-time = "2026-07-19T00:16:17.182Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/1e/1045ca2cabb12e8ec41ad0d138e9f3ff1eb079d30a6f51ccf7d709b44aad/regex-2026.7.19-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:062f8cb7a9739c4835d22bd96f370c59aba89f257adcfa53be3cc209e08d3ae0", size = 785300, upload-time = "2026-07-19T00:16:18.505Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4a/20e5bca184e90bf1bd187efdb53363f4a7b7b34f01d54ced5740caf104bd/regex-2026.7.19-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1123ef4211d763ee771d47916a1596e2f4915794f7aabdc1adcb20e4249a6951", size = 854079, upload-time = "2026-07-19T00:16:19.909Z" },
+    { url = "https://files.pythonhosted.org/packages/09/9b/5a2e59678be3b24aa6a42b2c6d66a48daa212593e9f4096fe7ba577fa9b1/regex-2026.7.19-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6e44c0e7c5664be20aee92085153150c0a7967310a73a43c0f832b7cd35d0dd3", size = 899496, upload-time = "2026-07-19T00:16:21.453Z" },
+    { url = "https://files.pythonhosted.org/packages/48/9a/7317f14ed8ed9fd998d1978b4802b07bc4d79216353c435dbcc1ddd1301f/regex-2026.7.19-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98c6ac18480fcdb33f35439183f1d2e79760ab41930309c6d951cb1f8e46694c", size = 793541, upload-time = "2026-07-19T00:16:22.991Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/53/833c2db3e274d3c191f4c42fe5bfa358e4c8b617d5d7312d31334965fc46/regex-2026.7.19-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4458124d71339f505bf1fb94f69fd1bb8fa9d2481eebfef27c10ef4f2b9e12f6", size = 785515, upload-time = "2026-07-19T00:16:24.654Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b9/efb2f9fa151d71db09d4015e1fb92fee47416f01c12164836bbd23e2f3c2/regex-2026.7.19-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fbf300e2070bb35038660b3be1be4b91b0024edb41517e6996320b49b92b4175", size = 769556, upload-time = "2026-07-19T00:16:26.207Z" },
+    { url = "https://files.pythonhosted.org/packages/81/4d/45610c263f8eadb84e4a1fabd904d81d5176226faa9104ef498bf8a8b285/regex-2026.7.19-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b2b506b1788df5fecd270a10d5e70a95fe77b87ea2b370a318043f6f5f817ee6", size = 774130, upload-time = "2026-07-19T00:16:27.786Z" },
+    { url = "https://files.pythonhosted.org/packages/40/95/1b40d87c7a9e5480bec7a87bce9fd67fc3f14b5f106c8ee66d660249072f/regex-2026.7.19-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:52579c60a6078be70a0e49c81d6e56d677f34cd439af281a0083b8c7bc75c095", size = 848694, upload-time = "2026-07-19T00:16:29.412Z" },
+    { url = "https://files.pythonhosted.org/packages/17/8b/bb45968addd5b394ef9cd9184bd9c65ade1a819dbb2b92b71ad52a0c7907/regex-2026.7.19-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:2955907b7157a6660f27079edf7e0229e9c9c5325c77a2ef6a890cba91efa6f0", size = 758505, upload-time = "2026-07-19T00:16:31.006Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/6f/33386c672fbf43e21602135a0f29a97ee251a483f007fe51d10e9b2dbc93/regex-2026.7.19-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:89dfee3319f5ae3f75ebd5c2445a809bb320252ba5529ffdafea4ef25d79cf1a", size = 836985, upload-time = "2026-07-19T00:16:32.459Z" },
+    { url = "https://files.pythonhosted.org/packages/22/f1/9112b86e9bb075619862e8e42b604794389f1958faa68fb69bde505dd90e/regex-2026.7.19-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d3143f159261b1ce5b24c261c590e5913370c3200c5e9ebbb92b5aa5e111902", size = 782610, upload-time = "2026-07-19T00:16:33.857Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/f9/13d460d8a385ca0b0be9e6be80a90968b9293b3e30895543ad2d1d1653e4/regex-2026.7.19-cp310-cp310-win32.whl", hash = "sha256:64729333167c2dcaaa56a331d40ee097bd9c5617ffd51dabb09eaddafb1b532e", size = 266772, upload-time = "2026-07-19T00:16:35.194Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/90/29addd7a03e1aea402c1f31467e25c80caabc8c3735b88a23cf73b0aa9c2/regex-2026.7.19-cp310-cp310-win_amd64.whl", hash = "sha256:1c398716054621aa300b3d411f467dda903806c5da0df6945ab73982b8d115db", size = 277967, upload-time = "2026-07-19T00:16:36.847Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ba/ecfce06fe66c122bc6f77ae284887a9282e4411fe1e6268c5266611ca054/regex-2026.7.19-cp310-cp310-win_arm64.whl", hash = "sha256:064f1760a5a4ade65c5419be23e782f29147528e8a66e0c42dd4cedb8d4e9fc6", size = 276963, upload-time = "2026-07-19T00:16:38.315Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "safetensors"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", hash = "sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d", size = 325846, upload-time = "2026-06-09T07:52:25.563Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/a0/f718cda65b05407d228f97602cf60dca269c979867aa5beb25410de26cd3/safetensors-0.8.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0", size = 473568, upload-time = "2026-06-09T07:52:18.829Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b1/fa7c600e7dceae12e9606c7578cbc9ff1e1ed55844883ee5c92205e86226/safetensors-0.8.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25", size = 484562, upload-time = "2026-06-09T07:52:17.518Z" },
+    { url = "https://files.pythonhosted.org/packages/09/7d/65a7de0af421317bb36a067241e4235fff194eed60b961ed6d3f59a3fc60/safetensors-0.8.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235", size = 502844, upload-time = "2026-06-09T07:52:07.624Z" },
+    { url = "https://files.pythonhosted.org/packages/91/4f/3175c9d75634e0e0dda0082794193521035edd7c70a6f212bf33ca06ddf4/safetensors-0.8.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0", size = 511823, upload-time = "2026-06-09T07:52:09.565Z" },
+    { url = "https://files.pythonhosted.org/packages/20/87/846c289e7aa2299eff406335717cf43ce8777194ece8aad75772e0411615/safetensors-0.8.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98", size = 633461, upload-time = "2026-06-09T07:52:11.128Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/8d64d9df2c45d5ded401df889d0ad90882804ca172d79ec4f0df8f727fe0/safetensors-0.8.0-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358", size = 545148, upload-time = "2026-06-09T07:52:13.603Z" },
+    { url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774", size = 516040, upload-time = "2026-06-09T07:52:16.29Z" },
+    { url = "https://files.pythonhosted.org/packages/46/fb/cdaed17ceb2948784fd9c36b6fd3e951b608547cea81a48e8ee6f8cfdfcb/safetensors-0.8.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78", size = 513832, upload-time = "2026-06-09T07:52:12.37Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/49/1e15de264dcc3b77943d2d0c56a95809956883b1c2d6d585c792523f180b/safetensors-0.8.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca", size = 559930, upload-time = "2026-06-09T07:52:14.743Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/43/bf38443278eab4b1be1fce2931e2b012ad9cb7df52ada751d0aab8f7659a/safetensors-0.8.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4", size = 678670, upload-time = "2026-06-09T07:52:20.032Z" },
+    { url = "https://files.pythonhosted.org/packages/72/e3/68cd3fa5b48488e84add63e04cb12f3bc28ae4638c06d4508c6e88823d0e/safetensors-0.8.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc", size = 786679, upload-time = "2026-06-09T07:52:21.322Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4b/1c19c509d56e01f4fbb3d0a2e597450f6cc04d1d56cf52defb0a62dfd715/safetensors-0.8.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d", size = 765683, upload-time = "2026-06-09T07:52:22.594Z" },
+    { url = "https://files.pythonhosted.org/packages/27/43/41c1621732edd934d868a00d1b891584c892a7b62a9aab82ea5a0a5623ee/safetensors-0.8.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846", size = 722361, upload-time = "2026-06-09T07:52:23.924Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/3f/73ccf82579412b4a71c4ca673f10b5f1f888d7cf5af7fe24f27d30307be4/safetensors-0.8.0-cp310-abi3-win32.whl", hash = "sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d", size = 342401, upload-time = "2026-06-09T07:52:28.895Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl", hash = "sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f", size = 355540, upload-time = "2026-06-09T07:52:27.832Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/fc/7eedc3510d97878876e32774eebbeb61c43f148a96e915c84229a3e967aa/safetensors-0.8.0-cp310-abi3-win_arm64.whl", hash = "sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452", size = 340500, upload-time = "2026-06-09T07:52:26.745Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "84.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]
+
+[[package]]
+name = "tokenizers"
+version = "0.22.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/97/5dbfabf04c7e348e655e907ed27913e03db0923abb5dfdd120d7b25630e1/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c", size = 3100275, upload-time = "2026-01-05T10:41:02.158Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/47/174dca0502ef88b28f1c9e06b73ce33500eedfac7a7692108aec220464e7/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001", size = 2981472, upload-time = "2026-01-05T10:41:00.276Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" },
+    { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" },
+    { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" },
+    { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" },
+    { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" },
+    { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" },
+    { url = "https://files.pythonhosted.org/packages/84/04/655b79dbcc9b3ac5f1479f18e931a344af67e5b7d3b251d2dcdcd7558592/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4", size = 3282301, upload-time = "2026-01-05T10:40:34.858Z" },
+    { url = "https://files.pythonhosted.org/packages/46/cd/e4851401f3d8f6f45d8480262ab6a5c8cb9c4302a790a35aa14eeed6d2fd/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c", size = 3161308, upload-time = "2026-01-05T10:40:40.737Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/6e/55553992a89982cd12d4a66dddb5e02126c58677ea3931efcbe601d419db/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195", size = 3718964, upload-time = "2026-01-05T10:40:46.56Z" },
+    { url = "https://files.pythonhosted.org/packages/59/8c/b1c87148aa15e099243ec9f0cf9d0e970cc2234c3257d558c25a2c5304e6/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5", size = 3373542, upload-time = "2026-01-05T10:40:52.803Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "sys_platform != 'linux' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "filelock", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "fsspec", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "jinja2", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "networkx", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "sympy", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "typing-extensions", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/d6/e6d4c57e61c2b2175d3aafbfb779926a2cfd7c32eeda7c543925dceec923/torch-2.8.0-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:a3f16a58a9a800f589b26d47ee15aca3acf065546137fc2af039876135f4c760", size = 73611154, upload-time = "2025-08-06T14:53:10.919Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.8.0+cu128"
+source = { registry = "https://download.pytorch.org/whl/cu128" }
+resolution-markers = [
+    "sys_platform == 'linux' or sys_platform == 'win32'",
+]
+dependencies = [
+    { name = "filelock", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "fsspec", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "jinja2", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "networkx", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "sympy", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.8.0%2Bcu128-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:0c96999d15cf1f13dd7c913e0b21a9a355538e6cfc10861a17158320292f5954", upload-time = "2025-10-01T23:47:19Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.8.0%2Bcu128-cp310-cp310-win_amd64.whl", hash = "sha256:43938e9a174c90e5eb9e906532b2f1e21532bbfa5a61b65193b4f54714d34f9e", upload-time = "2025-10-01T23:47:42Z" },
+]
+
+[[package]]
+name = "torchvision"
+version = "0.23.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "sys_platform != 'linux' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pillow", marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "torch", version = "2.8.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux' and sys_platform != 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/49/5ad5c3ff4920be0adee9eb4339b4fb3b023a0fc55b9ed8dbc73df92946b8/torchvision-0.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7266871daca00ad46d1c073e55d972179d12a58fa5c9adec9a3db9bbed71284a", size = 1856885, upload-time = "2025-08-06T14:57:55.024Z" },
+]
+
+[[package]]
+name = "torchvision"
+version = "0.23.0+cu128"
+source = { registry = "https://download.pytorch.org/whl/cu128" }
+resolution-markers = [
+    "sys_platform == 'linux' or sys_platform == 'win32'",
+]
+dependencies = [
+    { name = "numpy", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "pillow", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "torch", version = "2.8.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cu128/torchvision-0.23.0%2Bcu128-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:460bc8d70f63bdb433a7351decc2c1ae1903f7f378e4a7614fc8e8c97a5c36aa", upload-time = "2025-08-05T20:11:51Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torchvision-0.23.0%2Bcu128-cp310-cp310-win_amd64.whl", hash = "sha256:8ec6f2281ef5d52471b01b99eb04243d0c2cccb1972ba43217085025fe5a6c3f", upload-time = "2025-08-05T20:11:51Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.70.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" },
+]
+
+[[package]]
+name = "transformers"
+version = "4.57.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "regex" },
+    { name = "requests" },
+    { name = "safetensors" },
+    { name = "tokenizers" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", hash = "sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3", size = 10134912, upload-time = "2026-01-16T10:38:39.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", hash = "sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550", size = 11993498, upload-time = "2026-01-16T10:38:31.289Z" },
+]
+
+[[package]]
+name = "triton"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "setuptools", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/ee/0ee5f64a87eeda19bbad9bc54ae5ca5b98186ed00055281fd40fb4beb10e/triton-3.4.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ff2785de9bc02f500e085420273bb5cc9c9bb767584a4aa28d6e360cec70128", size = 155430069, upload-time = "2025-07-30T19:58:21.715Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]

manifests/phase21a_training_environment_v1.json

@@ -0,0 +1,42 @@
+{
+  "schema_version": "phase21a_training_environment_v1",
+  "captured_at": "2026-08-27",
+  "operating_system": "Ubuntu 22.04.5 LTS",
+  "python": "3.10.12",
+  "gpu_reference": {
+    "name": "NVIDIA GeForce RTX 5090",
+    "memory_mib": 32607,
+    "compute_capability": "12.0",
+    "driver": "580.173.02"
+  },
+  "cuda_runtime_from_torch": "12.8",
+  "packages": {
+    "torch": "2.8.0+cu128",
+    "torchvision": "0.23.0+cu128",
+    "transformers": "4.57.6",
+    "peft": "0.19.1",
+    "accelerate": "1.14.0",
+    "flash-attn": "2.8.3.post1",
+    "qwen-vl-utils": "0.0.14",
+    "numpy": "1.26.4",
+    "pillow": "11.3.0",
+    "safetensors": "0.8.0",
+    "huggingface-hub": "0.36.2",
+    "packaging": "26.2"
+  },
+  "base_model": {
+    "repo_id": "unsloth/Qwen3-VL-4B-Instruct",
+    "revision": "252d592b59b0233b226875a44ac135cfa1d3f755",
+    "license_reported_by_hub": "apache-2.0"
+  },
+  "upstream_robometer": {
+    "repository": "https://github.com/robometer/robometer",
+    "revision": "a669dffc241d7d76bec12f36efd4084d914d017c",
+    "environment_source": ["pyproject.toml", "uv.lock"]
+  },
+  "notes": [
+    "Do not upload or copy the local .venv; recreate it from a frozen lock or container.",
+    "Use a separate upload-only environment if upgrading huggingface-hub.",
+    "bitsandbytes is not required or allowed for formal Robometer-Low training."
+  ]
+}

manifests/phase2_remediation_pairs_v1_summary.json

@@ -0,0 +1,26 @@
+{
+  "status": "pass",
+  "role": "phase2_five_percent_id_only_remediation",
+  "seed": 1701,
+  "requested_confirmation_fraction_of_full_stream": 0.2,
+  "pair_count": 2689,
+  "original_stream_pair_count": 538,
+  "train_pair_count": 2021,
+  "original_dev_pair_count": 108,
+  "confirmation_dev_pair_count": 538,
+  "excluded_original_dev_component_pair_count": 22,
+  "component_count": 2393,
+  "eligible_confirmation_component_count": 1874,
+  "selected_confirmation_component_count": 495,
+  "original_dev_preserved_verbatim": true,
+  "five_percent_is_exact_one_percent_prefix_extension": true,
+  "confirmation_ids_seen_in_original_stream": 0,
+  "active_split_trajectory_id_overlaps": {
+    "train_dev": 0,
+    "train_confirmation_dev": 0,
+    "dev_confirmation_dev": 0
+  },
+  "active_unique_feature_sides": 5181,
+  "manifest": "manifests/phase2_remediation_pairs_v1.jsonl",
+  "manifest_sha256": "c77642e3d34177d1bfbcebe8c97cdf0af952c83d95a677cf42d95426b6d49204"
+}

provenance/source_revisions.yaml

@@ -0,0 +1,17 @@
+schema_version: phase21a_source_revisions_v1
+package_date: 2026-08-27
+workspace_base_revision: 2053d617d3a3dab8d008395948337d20e8947f57
+upstream_robometer:
+  repository: https://github.com/robometer/robometer
+  revision: a669dffc241d7d76bec12f36efd4084d914d017c
+base_model:
+  repo_id: unsloth/Qwen3-VL-4B-Instruct
+  revision: 252d592b59b0233b226875a44ac135cfa1d3f755
+processed_dataset:
+  repo_id: robometer/processed_datasets
+  revision: 1a8eb2d279c70964fadeaf8019a77c490c3abe02
+  local_profile: stage2_core_v1
+  exact_rbm1m_claim_allowed: false
+protocol:
+  config: configs/phase21a_robometer_low_lora_train_v2.yaml
+  manifest_sha256: c77642e3d34177d1bfbcebe8c97cdf0af952c83d95a677cf42d95426b6d49204

reports/PHASE21A_ROBOMETER_LOW_SMOKE_V1.md

@@ -0,0 +1,64 @@
+# Phase 2.1A Robometer-Low-LoRA smoke test
+
+## 结论
+
+Robometer-Low-LoRA 的真实数据 smoke 已通过。正式训练容量配置为：
+
+```text
+micro_batch_pairs = 32
+gradient_accumulation = 2
+effective_batch_pairs = 64
+```
+
+该配置在 RTX 5090 31.335 GiB 上、使用训练集中最长指令的真实 pair，完整执行了两个累计
+micro-step 和一次 optimizer update；峰值 allocated/reserved 为 26.114/28.150 GiB（reserved
+89.84%），吞吐 2.497 pair/s。总 loss、三个
+component loss 和全部可训练梯度有限；LoRA、新增特殊 token 行、preference/progress/success 三个
+head 的梯度范数均非零。
+
+本轮没有启动正式训练，也没有修改 Cosmos3-Edge。
+
+## 本轮 Robometer-Low-LoRA 定义
+
+保留真实 Robometer-on-Qwen 的结构操作：A/B 两条轨迹在同一次前向中联合输入；每帧后放置
+`<|prog_token|>`；两轨迹之间放置 `<|split_token|>`；末尾用 `<|pref_token|>` 做直接二分类；
+progress、success、preference head 均使用 `Linear(D,D/2) → LayerNorm → GELU → Dropout → Linear`。
+每个 pair 是 8+8=16 张真实 256×256 letterbox 图像。最终边界复验特意选取 train split 中任务
+文本最长的 8 个 pair（88–158 字符），自然序列长度为 1,302–1,319 token。
+
+“LoRA”表示参数高效训练：冻结视觉塔与语言基座，仅在语言注意力
+q/k/v/o 投影上训练 LoRA（r=8, alpha=16），同时训练五个新增特殊 token 的 embedding 行和三个
+预测头。总可训练参数 15,768,332，其中 LoRA+token rows 5,911,040，heads 9,857,292。
+
+命名中的 “Low” 只表示使用非完整版 Public-Proxy 数据；全量 decoder 版本命名为
+Robometer-Low，当前版本明确命名为 Robometer-Low-LoRA。
+
+## 容量搜索
+
+每个容量 probe 均在独立进程加载同一 Qwen 快照，并执行联合 16 帧的真实前向、三损失反向与
+optimizer update。显存安全规则预先固定为 peak reserved 不超过物理显存的 90%。
+
+| micro batch | grad accum | effective batch | peak reserved GiB | reserved % | pair/s | 判定 |
+|---:|---:|---:|---:|---:|---:|---|
+| 2 | 1 | 2 | 10.172 | 32.46 | 1.464 | pass |
+| 4 | 1 | 4 | 10.719 | 34.21 | 1.883 | pass |
+| 8 | 1 | 8 | 13.023 | 41.56 | 2.099 | pass |
+| 16 | 1 | 16 | 17.670 | 56.39 | 2.270 | pass |
+| 24 | 1 | 24 | 22.889 | 73.05 | 2.426 | pass |
+| 32 | 1 | 32 | 26.877 | 85.77 | 2.459 | pass |
+| 34 | 1 | 34 | 28.006 | 89.38 | 2.451 | single-step pass |
+| 35 | 1 | 35 | 28.658 | 91.46 | 2.477 | 越过安全线 |
+| 34 | 2 | 68 | 28.518 | 91.01 | 1.773 | 最长指令复验通过但越线 |
+| 33 | 2 | 66 | 27.982 | 89.30 | 2.446 | pass，后由用户改为 32 |
+| **32** | **2** | **64** | **28.150** | **89.84** | **2.497** | **最长指令复验，用户确认** |
+
+micro-batch 1 的首次运行包含 CUDA kernel/allocator warm-up，11.34 s 的耗时不用于吞吐比较；
+micro-batch 3、6 及全部原始点仍保存在 machine-readable 报告和 run JSON 中。表中 1–35 的
+单步搜索使用前缀 smoke pool；最终 33×2 与相邻 34×2 使用全量 train split 的最长指令 pool，
+最终 32×2 使用相同的最长指令 pool，是当前权威配置。
+
+## 边界与下一步
+
+这只证明实现可训练、三条 loss/gradient 路径接通以及单卡容量满足要求，不证明模型收敛或指标
+提升。正式 Phase 2.1A、学习率/步数、checkpoint 选择和 Cosmos3-Edge 对应改造仍未开始，需用户
+确认后另行执行。

reports/PHASE21A_STEP_BUDGET_V2.md

@@ -0,0 +1,50 @@
+# Phase 2.1A step budget v2
+
+Date: 2026-08-27
+
+## Decision
+
+Replace the inherited 15,000-step fixed run with a 3,000-step hard cap and
+pre-registered ID-dev early stopping. Apply the same cap and selection rule to
+Robometer-Low-LoRA and the future full-decoder Robometer-Low comparison.
+
+## Scale calculation
+
+- Frozen train set: 2,021 preference pairs.
+- Effective batch: 64 pairs per optimizer step.
+- 15,000 steps: 960,000 pair presentations, approximately 475 nominal passes.
+- 3,000-step cap: 192,000 pair presentations, approximately 95 nominal passes.
+- Minimum 1,000 steps: 64,000 pair presentations, approximately 32 nominal passes.
+
+The official 15,000-step value was copied from the million-scale RBM-1M recipe;
+it was not estimated from this 2,021-pair Low split.
+
+## Evidence from the stopped v1 run
+
+The user-stopped seed-7 run logged through step 246. Mean total train loss fell
+from 4.573 over steps 1-25 to 3.218 over steps 201-225; the last-100-step linear
+trend was still negative by about 0.455 per 100 steps. It had not converged.
+However, the 15,000-step scheduler used 750 warmup steps, so step 246 had reached
+only about 33% of the target learning rate. This curve cannot be extrapolated to
+justify 15,000 steps.
+
+## Selection protocol
+
+- Scheduler: cosine with 5% warmup; 150 warmup steps at the cap.
+- Evaluate every 250 steps on the original 108-pair `dev` split.
+- Evaluate both A/B orientations for each pair.
+- Select by the sum of mean preference, progress, and success ID-dev losses.
+- Minimum training: 1,000 steps.
+- Early stop after four consecutive evaluations without an improvement of at
+  least 0.005 ID-dev loss.
+- Restore the best ID-dev checkpoint for export.
+- Do not use `confirmation_dev` or RBM-EVAL-OOD for selection.
+
+The cap is a safety bound, not a claim that every seed needs exactly 3,000
+steps. The selected step is an experimental result recorded per seed.
+
+## Restart boundary
+
+The v1 run is not resumed into v2. Its latest complete checkpoint is step 4,
+and v2 changes both the scheduler horizon and checkpoint-selection protocol.
+All v2 seeds must start from the same pinned base model in a new output root.

reports/PHASE21A_TRAINING_MANUAL.md

@@ -0,0 +1,369 @@
+# Phase 2.1A 训练手册
+
+日期：2026-08-27  
+对象：`Robometer-Low-LoRA` 与 `Robometer-Low`  
+数据：`Public-Proxy stage2_core_v1` 的冻结 5% pair manifest
+
+## 1. 名称和不可变边界
+
+- `Robometer-Low-LoRA`：Qwen3-VL-4B 视觉塔和语言基座冻结；训练 attention LoRA、五个新增
+  token rows 和 progress/success/preference 三头。
+- `Robometer-Low`：视觉塔冻结；语言 decoder 全量微调；训练三个 heads；`use_peft=false`。
+- `Low` 只表示使用非完整版 Public-Proxy 数据，不表示量化或 LoRA。
+- 两者使用同一 2,021-pair train split、同一 A/B 联合输入、同一 8+8 帧、同一三损失合同。
+- Robometer-Low 正式训练只允许标准 `torch.optim.AdamW`；禁止 paged AdamW 8-bit。
+- OOD benchmark 不进入训练 loop、checkpoint selection 或超参数选择。
+
+冻结数据统计：2,689 rows，其中 train/dev/confirmation-dev/excluded 分别为
+2,021/108/538/22；manifest SHA256 为
+`c77642e3d34177d1bfbcebe8c97cdf0af952c83d95a677cf42d95426b6d49204`。
+
+## 2. 当前代码成熟度
+
+| 分支 | 状态 | 可以做什么 |
+|---|---|---|
+| Robometer-Low-LoRA v1 | 已按用户要求停止 | 日志到 step 246；最新完整 checkpoint 为 step 4 |
+| Robometer-Low-LoRA v2 | 已配置，未正式启动 | 3,000-step cap、在线 ID-dev、早停和最佳 checkpoint 恢复 |
+| Robometer-Low | 等待服务器资源和正式 runner | 单卡容量 smoke；不能把当前 smoke 当正式训练入口 |
+
+LoRA v1 已停止且不再续训。v2 使用全新 output root；禁止拿 v1 的 step-4 checkpoint 恢复到 v2，
+因为总预算、scheduler 和选择协议均已改变。
+
+## 3. 参考环境
+
+已验证环境：
+
+| 项目 | 版本 |
+|---|---|
+| OS | Ubuntu 22.04.5 LTS |
+| Python | 3.10.12 |
+| NVIDIA driver | 580.173.02 |
+| PyTorch / CUDA runtime | 2.8.0+cu128 / 12.8 |
+| torchvision | 0.23.0+cu128 |
+| transformers | 4.57.6 |
+| PEFT | 0.19.1 |
+| accelerate | 1.14.0 |
+| flash-attn | 2.8.3.post1 |
+| qwen-vl-utils | 0.0.14 |
+| NumPy / Pillow | 1.26.4 / 11.3.0 |
+
+可部署环境固定在 `environment/phase21a_robometer/pyproject.toml` 和 `uv.lock`，不复制 `.venv`：
+
+```bash
+cd /srv/phase21a-kit
+uv python install 3.10.12
+uv sync --project environment/phase21a_robometer --frozen
+uv run --project environment/phase21a_robometer \
+  python environment/phase21a_robometer/doctor.py
+```
+
+如果上传包内保存了相同 `pyproject.toml` 和 `uv.lock`，仍要在目标 CUDA/driver 上重新创建环境。
+不要为上传工具升级训练 venv；`hf` CLI 可使用单独小环境。
+
+## 4. 下载并固定输入
+
+以下使用示例变量；按服务器目录修改：
+
+```bash
+PHASE21A_KIT=/srv/phase21a-kit
+PHASE21A_DATA=/srv/phase21a-data
+PHASE21A_MODEL=/srv/models/qwen3-vl-4b-instruct-252d592
+PHASE21A_RUNS=/srv/phase21a-runs
+```
+
+下载 training kit 和 dataset：
+
+```bash
+hf download ar-mine/cosmos-robometer-private-code \
+  --revision <KIT_COMMIT> \
+  --local-dir "$PHASE21A_KIT"
+
+hf download ar-mine/cosmos-robometer-public-dataset \
+  --repo-type dataset \
+  --revision <DATA_COMMIT> \
+  --local-dir "$PHASE21A_DATA"
+```
+
+下载精确基础模型；不要使用浮动 `main`：
+
+```bash
+hf download unsloth/Qwen3-VL-4B-Instruct \
+  --revision 252d592b59b0233b226875a44ac135cfa1d3f755 \
+  --local-dir "$PHASE21A_MODEL"
+```
+
+## 5. 开跑前共同门禁
+
+### 5.1 文件完整性
+
+```bash
+cd "$PHASE21A_DATA"
+sha256sum --check SHA256SUMS
+```
+
+再运行 dataset bundle 工具的 dry-run，把 `--output-dir` 指向任意不会执行复制的路径：
+
+```bash
+cd "$PHASE21A_KIT"
+uv run --project environment/phase21a_robometer python scripts/build_phase21a_hf_dataset_bundle.py \
+  --manifest "$PHASE21A_DATA/manifests/phase2_remediation_pairs_v1.jsonl" \
+  --processed-root "$PHASE21A_DATA/processed_datasets" \
+  --output-dir /tmp/phase21a-dry-run
+```
+
+必须得到：2,689 rows、4,323 unique frame files、0 missing、7.908 GiB。
+
+### 5.2 GPU/软件门禁
+
+```bash
+nvidia-smi
+uv run --project environment/phase21a_robometer \
+  python environment/phase21a_robometer/doctor.py
+```
+
+必须确认：BF16 可用、FlashAttention 2 可加载、模型 snapshot 离线可读、目标输出盘有足够空间。
+
+### 5.3 数据和评测隔离
+
+- formal trainer 只读取 `split=train` 且 `sample_type=preference`，精确为 2,021 pairs。
+- dev/confirmation-dev 只能用于 ID 报告或预注册 checkpoint selection。
+- `excluded_original_dev_component` 不得回流训练。
+- RBM-EVAL-OOD 不下载到训练节点也可以；不得据其结果调参。
+
+## 6. Robometer-Low-LoRA
+
+### 6.1 冻结配置
+
+| 参数 | 值 |
+|---|---:|
+| base | `unsloth/Qwen3-VL-4B-Instruct@252d592...` |
+| frames per pair | A 8 + B 8 |
+| canvas | 256×256 letterbox |
+| LoRA | r=8, alpha=16, dropout=0.05 |
+| LoRA targets | q/k/v/o projections |
+| trainable | LoRA + 5 special-token rows + 3 heads |
+| trainable params | 15,768,332 |
+| micro batch | 32 pairs |
+| gradient accumulation | 2 |
+| effective batch | 64 pairs |
+| precision | BF16 |
+| attention | FlashAttention 2 |
+| activation checkpointing | enabled |
+| optimizer | standard AdamW |
+| LoRA LR / heads LR | 2e-6 / 1e-4 |
+| weight decay | 0.01 |
+| scheduler | cosine, 5% warmup |
+| grad clip | 1.0 |
+| steps | 3,000 hard cap per seed；ID-dev early stop |
+| seeds | 7, 17, 27 |
+| checkpoint/eval | every 250 steps；min 1,000；patience 4；min delta 0.005 |
+
+新增 token 的顺序必须保持：
+
+```text
+<|split_token|>, <|reward_token|>, <|pref_token|>, <|sim_token|>, <|prog_token|>
+```
+
+在当前 base revision 上对应 ID 为 151669–151673。
+
+### 6.2 单步 smoke
+
+在新服务器上必须先跑最长 prompt pool 的真实一步：
+
+```bash
+cd "$PHASE21A_KIT"
+uv run --project environment/phase21a_robometer python scripts/smoke_phase21a_robometer_low.py \
+  --snapshot "$PHASE21A_MODEL" \
+  --manifest "$PHASE21A_DATA/manifests/phase2_remediation_pairs_v1.jsonl" \
+  --processed-root "$PHASE21A_DATA/processed_datasets" \
+  --micro-batch-pairs 32 \
+  --gradient-accumulation 2 \
+  --optimizer-steps 1 \
+  --pair-pool-size 8 \
+  --seed 7 \
+  --lora-lr 2e-6 \
+  --head-lr 1e-4 \
+  --output /tmp/phase21a_lora_smoke.json
+```
+
+通过条件：
+
+- `status=pass`；
+- effective batch 精确 64；
+- sequence max 不超过已知最长 1,319 tokens；
+- 三个 loss 有限；
+- LoRA、token rows、三个 heads 的梯度都有限且非零；
+- 峰值 reserved 不超过本机显存安全线。RTX 5090 参考值为 28.150 GiB，但其他 GPU 不应机械套用。
+
+### 6.3 正式启动
+
+portable runner 已支持显式模型、manifest 和数据路径：
+
+```bash
+cd "$PHASE21A_KIT"
+uv run --project environment/phase21a_robometer python scripts/run_phase21a_robometer_low_lora_seeds.py \
+  --snapshot "$PHASE21A_MODEL" \
+  --manifest "$PHASE21A_DATA/manifests/phase2_remediation_pairs_v1.jsonl" \
+  --processed-root "$PHASE21A_DATA/processed_datasets" \
+  --output-root "$PHASE21A_RUNS/robometer-low-lora-v2" \
+  --seeds 7 17 27 \
+  --optimizer-steps 3000 \
+  --micro-batch-pairs 32 \
+  --gradient-accumulation 2 \
+  --lora-lr 2e-6 \
+  --head-lr 1e-4 \
+  --checkpoint-every 250 \
+  --eval-every 250 \
+  --early-stop-min-steps 1000 \
+  --early-stop-patience-evals 4 \
+  --early-stop-min-delta 0.005
+```
+
+生产服务器上应由 Slurm、systemd 或其他作业调度器托管；不要依赖普通 SSH shell 的 `&`。每次只运行
+一个 runner，避免两个进程写同一 output root。
+
+### 6.4 恢复
+
+runner 会检测每个 seed 的：
+
+- 有 `summary.json`：跳过已完成 seed；
+- 有 `latest_training_state.pt`：自动加 `--resume`；
+- 两者都没有：从 step 0 开始。
+
+完整 checkpoint 包含 adapter、heads、AdamW、scheduler、NumPy/PyTorch/CUDA RNG、数据 permutation
+和 cursor。恢复前不得修改 manifest；trainer 会核对 manifest SHA256 和 seed。
+
+### 6.5 监控
+
+```bash
+tail -f "$PHASE21A_RUNS/robometer-low-lora-v2/seed_7/progress.jsonl"
+nvidia-smi
+```
+
+每条 progress record 应包含三个 loss、全局和分组梯度、LR、序列长度、step time 和显存。立即停止的
+异常包括：NaN/Inf、任一必要梯度组为零、manifest hash 改变、frame file 缺失或 OOM。
+
+RTX 5090 当前参考吞吐约 23–24 秒/step、2.7 pairs/s；硬件和温控会改变 ETA。
+
+### 6.6 完成产物
+
+每个 seed 完成后应出现：
+
+```text
+seed_<n>/
+├── adapter/
+├── reward_heads.pt
+├── best_model_state.pt
+├── latest_training_state.pt
+├── progress.jsonl
+├── id_dev_metrics.jsonl
+└── summary.json
+```
+
+发布前另外保存 processor/tokenizer 和特殊 token map；对外权重优先使用 safetensors。v2 的
+`adapter/` 和 `reward_heads.pt` 会恢复为 ID-dev 最佳 step，而不是机械使用最后一步。
+
+## 7. Robometer-Low 全量 decoder 训练
+
+### 7.1 当前禁止直接正式启动
+
+单张 RTX 5090 上，标准 AdamW 即使 `micro_batch_pairs=1` 也在第一次 optimizer-state 初始化时 OOM。
+PagedAdamW8bit 虽能跑通容量 smoke，但用户已明确禁止其用于正式 Robometer-Low。
+
+当前 `smoke_phase21a_robometer_low_full.py` 只是容量和梯度审计工具，不具备：
+
+- 多 GPU/FSDP；
+- 正式 3,000-step cap 和 ID-dev 早停的可恢复状态；
+- distributed RNG/data cursor 恢复；
+- sharded optimizer checkpoint；
+- 三 seed runner。
+
+因此在正式 full runner 实现并通过下述门禁前，Robometer-Low 状态保持
+`waiting_for_server_resources`，不能把 smoke 循环延长后冒充正式训练。
+
+### 7.2 目标正式配置
+
+| 参数 | 目标值 |
+|---|---:|
+| vision encoder | frozen |
+| language decoder | full trainable，`use_peft=false` |
+| heads | full trainable |
+| language trainable params | 约 4.0218B |
+| heads trainable params | 9.857M |
+| optimizer | standard torch AdamW，禁止 bitsandbytes/paged |
+| LR | 2e-5 |
+| weight decay | 0.01 |
+| precision/attention | BF16 / FlashAttention 2 |
+| activation checkpointing | enabled |
+| scheduler | cosine，5% warmup |
+| grad clip | 10.0（与当前 full smoke/官方设置一致） |
+| global effective batch | 至少且优先精确为 64 pairs |
+| steps/seeds | 3,000 hard cap + 与 LoRA 相同 ID-dev 早停；7/17/27 |
+
+分布式 global batch 计算公式：
+
+```text
+global_effective_batch = micro_batch_pairs_per_gpu × world_size × gradient_accumulation
+```
+
+例如 4 GPU、每卡 micro batch 8、accumulation 2 得到 64；这只是算术示例，必须以目标硬件 capacity
+smoke 为准。
+
+### 7.3 正式 runner 的实现门禁
+
+正式代码必须满足：
+
+1. 复用 LoRA v1 的 portable manifest loader、联合 A/B prompt、五 token 顺序和三 heads；
+2. 只冻结视觉塔，语言 decoder 全量 `requires_grad=True`；
+3. optimizer 类型审计精确为 `torch.optim.AdamW`，代码路径不导入 bitsandbytes；
+4. FSDP `FULL_SHARD` 包裹 `Qwen3VLTextDecoderLayer`，并验证无未分片的巨型语言层；
+5. global effective batch 精确记录并达到 64；
+6. 每 rank 数据不重复，分布式 sampler 的 epoch/order/cursor 可恢复；
+7. checkpoint 包含模型、heads、optimizer、scheduler、scaler（如有）、全部 RNG 和 sampler state；
+8. 中间 checkpoint 优先 sharded state，最终再受控合并，避免 rank 0 保存时 OOM；
+9. rank 0 写日志，所有 rank 对 NaN/OOM/数据异常做同步失败；
+10. OOD 不进入训练或选择。
+
+上游 Robometer 的 `robometer/configs/distributed/fsdp.yaml` 可作为 FSDP 配置参考，但官方
+`train.py` 不能直接替代本实验 runner：其默认 PEFT 为 r=32 且覆盖 MLP projections，数据采样和当前
+冻结 manifest 也不同。直接运行官方命令会形成另一个 protocol。
+
+### 7.4 服务器验收顺序
+
+1. 在隔离进程中加载模型，确认视觉 trainable=0、语言和 heads 数量正确；
+2. 用最长 prompt 跑一次 FSDP forward/backward/标准 AdamW step；
+3. 尝试相邻 micro batches，选择峰值显存不超过 90% 的最大安全值；
+4. 通过 accumulation 调整 global effective batch 到 64；
+5. 跑 100-step stability smoke，要求 0 NaN/Inf、0 OOM、0 empty mask；
+6. 在 step 50 保存，重启后恢复到 51，并与不中断参考运行核对 loss/LR/data cursor；
+7. 固定代码 commit、FSDP config hash、world size 和环境后，才允许三 seed 正式启动。
+
+### 7.5 多 GPU checkpoint 和发布
+
+- 训练 checkpoint 保留 sharded optimizer state，供相同或兼容 world size 恢复。
+- 发布 checkpoint 只在训练结束后合并；合并节点要有足够 CPU RAM 和磁盘临时空间。
+- 模型卡必须注明 base revision、数据 commit、world size、global batch、FSDP strategy 和标准 AdamW。
+- 任何使用 8-bit/paged optimizer 的结果必须另命名为实验性分支，不能称为 Robometer-Low。
+
+## 8. 最终开跑检查表
+
+### LoRA
+
+- [ ] kit/data/model 三个 commit/revision 已固定
+- [ ] SHA256 全通过，4,323/4,323 frame files 可解析
+- [ ] 单步 smoke 通过且显存安全
+- [ ] output root 全新或只有可信完整 checkpoint
+- [ ] 作业调度器托管，只有一个 runner
+- [ ] seeds 7/17/27、3,000-step cap、ID-dev 早停、effective batch 64
+- [ ] OOD 未接入训练 loop
+
+### Full
+
+- [ ] 服务器资源已分配
+- [ ] 自定义正式 FSDP runner 已实现和 code review
+- [ ] standard AdamW 类型审计通过，代码不走 bitsandbytes
+- [ ] 100-step 和断点恢复一致性门禁通过
+- [ ] global effective batch=64
+- [ ] vision frozen、language full trainable
+- [ ] 中间 sharded checkpoint 与最终合并流程均验证
+- [ ] 完成上述全部条件后才从 `waiting_for_server_resources` 改为 `running`

reports/phase21a_robometer_low_smoke_v1.json

@@ -0,0 +1,89 @@
+{
+  "status": "pass_awaiting_user_confirmation_before_formal_work",
+  "protocol_id": "phase21a_robometer_low_lora_smoke_v1",
+  "phase": "Phase 2.1A",
+  "model": "Robometer-Low-LoRA",
+  "completed_at_local": "2026-08-27T16:46:00+08:00",
+  "scope": {
+    "smoke_only": true,
+    "formal_training_started": false,
+    "cosmos3_edge_modified": false
+  },
+  "contract": {
+    "data_route": "Public-Proxy stage2_core_v1",
+    "real_pair_pool_size": 8,
+    "final_pair_pool_selection": "longest_prompt_characters_in_train_split",
+    "final_pair_pool_prompt_character_range": [88, 158],
+    "frames_per_trajectory": 8,
+    "frames_per_joint_pair_forward": 16,
+    "canvas": [256, 256],
+    "preference": "direct BCE from <|pref_token|>",
+    "progress": "10-bin soft cross entropy from per-frame <|prog_token|>",
+    "success": "balanced BCE from per-frame <|prog_token|>",
+    "vision_frozen": true,
+    "language": "LoRA r8 alpha16 dropout0.05 on q/k/v/o",
+    "new_special_token_rows_trainable": true,
+    "trainable_heads": ["preference", "progress", "success"],
+    "precision": "BF16",
+    "gradient_checkpointing": true,
+    "attention": "flash_attention_2"
+  },
+  "official_robometer_training_reference": {
+    "train_vision_encoder": false,
+    "train_language_model": true,
+    "use_peft": false,
+    "interpretation": "official default fully fine-tunes the language decoder; this result is explicitly named Robometer-Low-LoRA"
+  },
+  "parameter_audit": {
+    "base_total": 4443056128,
+    "backbone_trainable_lora_and_token_rows": 5911040,
+    "heads_trainable": 9857292,
+    "all_trainable": 15768332
+  },
+  "gpu": {
+    "name": "NVIDIA GeForce RTX 5090",
+    "total_gib": 31.33453369140625,
+    "peak_reserved_limit_fraction": 0.90
+  },
+  "capacity_probes": [
+    {"micro_batch_pairs": 1, "peak_reserved_gib": 9.44921875, "peak_reserved_fraction": 0.3015592586460454, "pairs_per_second": 0.08816775947063833, "status": "pass_compile_warmup_timing_outlier"},
+    {"micro_batch_pairs": 2, "peak_reserved_gib": 10.171875, "peak_reserved_fraction": 0.32462187247387436, "pairs_per_second": 1.4644908823074159, "status": "pass"},
+    {"micro_batch_pairs": 3, "peak_reserved_gib": 10.171875, "peak_reserved_fraction": 0.32462187247387436, "pairs_per_second": 1.8326653558369463, "status": "pass"},
+    {"micro_batch_pairs": 4, "peak_reserved_gib": 10.71875, "peak_reserved_fraction": 0.3420746613165558, "pairs_per_second": 1.8833336172113138, "status": "pass"},
+    {"micro_batch_pairs": 6, "peak_reserved_gib": 11.853515625, "peak_reserved_fraction": 0.37828919816511974, "pairs_per_second": 2.0176592085188503, "status": "pass"},
+    {"micro_batch_pairs": 8, "peak_reserved_gib": 13.0234375, "peak_reserved_fraction": 0.4156257000107132, "pairs_per_second": 2.0987864768533617, "status": "pass"},
+    {"micro_batch_pairs": 16, "peak_reserved_gib": 17.669921875, "peak_reserved_fraction": 0.5639120737847814, "pairs_per_second": 2.2696475376426384, "status": "pass"},
+    {"micro_batch_pairs": 24, "peak_reserved_gib": 22.888671875, "peak_reserved_fraction": 0.7304615444549413, "pairs_per_second": 2.4263013301323024, "status": "pass"},
+    {"micro_batch_pairs": 32, "peak_reserved_gib": 26.876953125, "peak_reserved_fraction": 0.8577422402290679, "pairs_per_second": 2.4586052936303937, "status": "pass"},
+    {"micro_batch_pairs": 34, "peak_reserved_gib": 28.005859375, "peak_reserved_fraction": 0.8937697829114603, "pairs_per_second": 2.4506286870197433, "status": "pass_single_microstep"},
+    {"micro_batch_pairs": 35, "peak_reserved_gib": 28.658203125, "peak_reserved_fraction": 0.9145884667452302, "pairs_per_second": 2.4765409697399408, "status": "pass_but_rejected_over_memory_limit"}
+  ],
+  "accumulation_boundary_checks": [
+    {"micro_batch_pairs": 34, "gradient_accumulation": 2, "effective_batch_pairs": 68, "pair_pool_selection": "longest_prompt_characters_in_train_split", "sequence_tokens_max": 1319, "peak_reserved_gib": 28.517578125, "peak_reserved_fraction": 0.9101006067571121, "pairs_per_second": 1.7730906691413035, "status": "pass_but_rejected_over_memory_limit"},
+    {"micro_batch_pairs": 33, "gradient_accumulation": 2, "effective_batch_pairs": 66, "pair_pool_selection": "longest_prompt_characters_in_train_split", "sequence_tokens_max": 1319, "peak_allocated_gib": 26.66872262954712, "peak_reserved_gib": 27.982421875, "peak_reserved_fraction": 0.8930218062467739, "pairs_per_second": 2.445795899300712, "seconds_per_microstep": 13.492540407576598, "status": "pass_superseded_by_user_batch_selection"},
+    {"micro_batch_pairs": 32, "gradient_accumulation": 2, "effective_batch_pairs": 64, "pair_pool_selection": "longest_prompt_characters_in_train_split", "sequence_tokens_max": 1319, "peak_allocated_gib": 26.11378002166748, "peak_reserved_gib": 28.150390625, "peak_reserved_fraction": 0.898382305677026, "pairs_per_second": 2.496645440085846, "seconds_per_microstep": 12.817198424017988, "status": "selected_pass_user_confirmed"}
+  ],
+  "selected": {
+    "micro_batch_pairs": 32,
+    "gradient_accumulation": 2,
+    "effective_batch_pairs": 64,
+    "selection_reason": "user_confirmed_exact_effective_batch_64",
+    "optimizer_steps_validated": 1,
+    "microsteps_validated": 2,
+    "pair_pool_selection": "longest_prompt_characters_in_train_split",
+    "sequence_tokens_max": 1319,
+    "peak_allocated_gib": 26.11378002166748,
+    "peak_reserved_gib": 28.150390625,
+    "peak_reserved_fraction": 0.898382305677026,
+    "pairs_per_second": 2.496645440085846,
+    "loss_all_finite": true,
+    "gradient_all_finite": true,
+    "all_required_gradient_groups_nonzero": true
+  },
+  "artifacts": {
+    "selected_raw": "runs/phase21a_robometer_low_smoke_v1/worstcase_mb32_ga2_eff64.json",
+    "rejected_adjacent_raw": "runs/phase21a_robometer_low_smoke_v1/worstcase_mb34_ga2_eff68.json",
+    "script_sha256": "4d1ddd53cb26b1c9115808ff65ae21ecf8de36ca322bc0a2449ce4a9fd00fe89",
+    "config_sha256_before_final_result_annotation": "02ef3a8ff8dc35766ecd4c0800866522218f6ae0768a898b381b9ef6a18d7422"
+  }
+}

scripts/build_phase21a_hf_dataset_bundle.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Materialize the minimal portable Phase 2.1A dataset bundle.
+
+The source view may contain symlinks into cold storage. This script copies only
+frame archives referenced by the frozen manifest and preserves their relative
+paths so ``--processed-root <bundle>/processed_datasets`` remains valid.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+from pathlib import Path
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(8 * 1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--processed-root", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Copy files and write inventory; without this flag only print the plan.",
+    )
+    args = parser.parse_args()
+
+    manifest = args.manifest.resolve()
+    # Preserve the lexical parent because ``processed_root`` is commonly a
+    # symlink named ``processed_datasets`` and manifest paths include that name.
+    processed_root = args.processed_root.absolute()
+    source_root = processed_root.parent
+    output = args.output_dir.resolve()
+    resolved_processed_root = processed_root.resolve()
+    if output == resolved_processed_root or resolved_processed_root in output.parents:
+        raise ValueError("output directory must not be inside the source dataset view")
+
+    rows = [json.loads(line) for line in manifest.read_text(encoding="utf-8").splitlines() if line]
+    references: set[str] = set()
+    split_counts: dict[str, int] = {}
+    for row in rows:
+        split = str(row["split"])
+        split_counts[split] = split_counts.get(split, 0) + 1
+        for role in ("chosen", "rejected"):
+            value = str(row[role]["source_frame_file"])
+            relative = Path(value)
+            if relative.is_absolute() or ".." in relative.parts:
+                raise ValueError(f"non-portable frame path: {value}")
+            if relative.parts and relative.parts[0] == ".":
+                relative = Path(*relative.parts[1:])
+            if not relative.parts or relative.parts[0] != "processed_datasets":
+                raise ValueError(f"frame path is outside processed_datasets: {value}")
+            references.add(relative.as_posix())
+
+    sources: list[tuple[str, Path, int]] = []
+    for relative in sorted(references):
+        relative_path = Path(relative)
+        source = resolved_processed_root / Path(*relative_path.parts[1:])
+        if not source.is_file():
+            raise FileNotFoundError(source)
+        sources.append((relative, source, source.stat().st_size))
+
+    plan = {
+        "status": "ready" if args.execute else "dry_run",
+        "manifest": str(manifest),
+        "manifest_sha256": sha256(manifest),
+        "pair_rows": len(rows),
+        "split_counts": split_counts,
+        "unique_frame_files": len(sources),
+        "frame_bytes": sum(size for _, _, size in sources),
+        "frame_gib": sum(size for _, _, size in sources) / 2**30,
+        "output_dir": str(output),
+    }
+    if not args.execute:
+        print(json.dumps(plan, indent=2, sort_keys=True))
+        return
+
+    manifest_target = output / "manifests" / manifest.name
+    manifest_target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(manifest, manifest_target)
+    summary_source = manifest.with_name(f"{manifest.stem}_summary.json")
+    if summary_source.is_file():
+        shutil.copy2(summary_source, manifest_target.parent / summary_source.name)
+
+    inventory = []
+    checksum_lines = []
+    for index, (relative, source, size) in enumerate(sources, start=1):
+        target = output / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if not target.is_file() or target.stat().st_size != size:
+            shutil.copy2(source, target)
+        checksum = sha256(target)
+        inventory.append({"path": relative, "bytes": size, "sha256": checksum})
+        checksum_lines.append(f"{checksum}  {relative}\n")
+        if index % 100 == 0:
+            print(f"materialized {index}/{len(sources)}", flush=True)
+
+    inventory_payload = dict(plan)
+    inventory_payload["status"] = "complete"
+    inventory_payload["files"] = inventory
+    (output / "phase21a_data_inventory.json").write_text(
+        json.dumps(inventory_payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    (output / "SHA256SUMS").write_text("".join(checksum_lines), encoding="utf-8")
+    print(json.dumps({key: value for key, value in inventory_payload.items() if key != "files"}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/run_phase21a_robometer_low_lora_seeds.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Run the three Phase 2.1A v2 Robometer-Low-LoRA seeds serially with resume."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+TRAINER = ROOT / "scripts" / "train_phase21a_robometer_low_lora.py"
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--snapshot", type=Path, required=True)
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=ROOT / "manifests" / "phase2_remediation_pairs_v1.jsonl",
+    )
+    parser.add_argument(
+        "--processed-root",
+        type=Path,
+        default=ROOT / "artifacts" / "data_views" / "phase1_official" / "processed_datasets",
+    )
+    parser.add_argument("--seeds", type=int, nargs="+", default=[7, 17, 27])
+    parser.add_argument("--optimizer-steps", type=int, default=3000)
+    parser.add_argument("--micro-batch-pairs", type=int, default=32)
+    parser.add_argument("--gradient-accumulation", type=int, default=2)
+    parser.add_argument("--lora-lr", type=float, default=2.0e-6)
+    parser.add_argument("--head-lr", type=float, default=1.0e-4)
+    parser.add_argument("--checkpoint-every", type=int, default=250)
+    parser.add_argument("--eval-every", type=int, default=250)
+    parser.add_argument("--eval-micro-batch-pairs", type=int, default=32)
+    parser.add_argument("--early-stop-min-steps", type=int, default=1000)
+    parser.add_argument("--early-stop-patience-evals", type=int, default=4)
+    parser.add_argument("--early-stop-min-delta", type=float, default=5.0e-3)
+    args = parser.parse_args()
+    for seed in args.seeds:
+        output = args.output_root / f"seed_{seed}"
+        if (output / "summary.json").is_file():
+            continue
+        command = [
+            sys.executable,
+            str(TRAINER),
+            "--snapshot", str(args.snapshot),
+            "--manifest", str(args.manifest),
+            "--processed-root", str(args.processed_root),
+            "--seed", str(seed),
+            "--optimizer-steps", str(args.optimizer_steps),
+            "--micro-batch-pairs", str(args.micro_batch_pairs),
+            "--gradient-accumulation", str(args.gradient_accumulation),
+            "--lora-lr", str(args.lora_lr),
+            "--head-lr", str(args.head_lr),
+            "--checkpoint-every", str(args.checkpoint_every),
+            "--eval-every", str(args.eval_every),
+            "--eval-micro-batch-pairs", str(args.eval_micro_batch_pairs),
+            "--early-stop-min-steps", str(args.early_stop_min_steps),
+            "--early-stop-patience-evals", str(args.early_stop_patience_evals),
+            "--early-stop-min-delta", str(args.early_stop_min_delta),
+            "--output-dir", str(output),
+        ]
+        if (output / "latest_training_state.pt").is_file():
+            command.append("--resume")
+        subprocess.run(command, check=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/smoke_phase21a_robometer_low.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python3
+"""One isolated Robometer-Low smoke run on real Route-A preference pairs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import random
+import sys
+import time
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+
+
+EXPERIMENT_ROOT = Path(__file__).resolve().parents[1]
+if str(EXPERIMENT_ROOT) not in sys.path:
+    sys.path.insert(0, str(EXPERIMENT_ROOT))
+
+from src.data_contract import letterbox_rgb  # noqa: E402
+
+
+SPECIAL_TOKENS = (
+    "<|split_token|>",
+    "<|reward_token|>",
+    "<|pref_token|>",
+    "<|sim_token|>",
+    "<|prog_token|>",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--snapshot", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--processed-root", type=Path, required=True)
+    parser.add_argument("--micro-batch-pairs", type=int, required=True)
+    parser.add_argument("--gradient-accumulation", type=int, required=True)
+    parser.add_argument("--optimizer-steps", type=int, default=1)
+    parser.add_argument("--pair-pool-size", type=int, default=8)
+    parser.add_argument("--seed", type=int, default=7)
+    parser.add_argument("--head-lr", type=float, default=1.0e-4)
+    parser.add_argument("--lora-lr", type=float, default=2.0e-6)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+class RobometerHeads(nn.Module):
+    """Exact Robometer prediction-head topology, with 10-bin progress."""
+
+    def __init__(self, hidden_size: int, dropout: float = 0.1) -> None:
+        super().__init__()
+        self.progress_head = self._head(hidden_size, 10, dropout)
+        self.success_head = self._head(hidden_size, 1, dropout)
+        self.preference_head = self._head(hidden_size, 1, dropout)
+
+    @staticmethod
+    def _head(hidden_size: int, output_size: int, dropout: float) -> nn.Sequential:
+        return nn.Sequential(
+            nn.Linear(hidden_size, hidden_size // 2),
+            nn.LayerNorm(hidden_size // 2),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_size // 2, output_size),
+        )
+
+
+def read_train_rows(path: Path, count: int) -> list[dict]:
+    candidates = []
+    with path.open("r", encoding="utf-8") as stream:
+        for line in stream:
+            row = json.loads(line)
+            if row["split"] == "train" and row["sample_type"] == "preference":
+                candidates.append(row)
+    # Capacity must cover the worst text-padding case in the formal manifest.
+    rows = sorted(candidates, key=lambda row: len(row["prompt_task"]), reverse=True)[:count]
+    if len(rows) < count:
+        raise RuntimeError(f"requested {count} smoke rows, found {len(rows)}")
+    if not any(row["chosen"]["progress_supervised"] for row in rows):
+        raise RuntimeError("smoke pool has no progress-supervised chosen trajectory")
+    if not any(any(row["chosen"]["success_label"]) for row in rows):
+        raise RuntimeError("smoke pool has no positive success label")
+    return rows
+
+
+def resolve_frame_file(value: str, processed_root: Path) -> Path:
+    path = Path(value)
+    if path.is_absolute():
+        return path
+    resolved = (processed_root.parent / path).resolve()
+    if not resolved.is_file():
+        raise FileNotFoundError(resolved)
+    return resolved
+
+
+@lru_cache(maxsize=64)
+def load_trajectory_cached(
+    frame_path_string: str, selected_indices: tuple[int, ...]
+) -> tuple[Image.Image, ...]:
+    with np.load(frame_path_string) as archive:
+        frames = archive["frames"][np.asarray(selected_indices, dtype=np.int64)]
+    return tuple(Image.fromarray(letterbox_rgb(frame, 256)) for frame in frames)
+
+
+def load_images(record: dict, processed_root: Path) -> tuple[Image.Image, ...]:
+    frame_path = resolve_frame_file(record["source_frame_file"], processed_root)
+    return load_trajectory_cached(
+        str(frame_path), tuple(int(index) for index in record["selected_frame_indices"])
+    )
+
+
+def build_conversation(
+    row: dict, processed_root: Path, chosen_is_a: bool
+) -> tuple[list[dict], dict, float]:
+    record_a = row["chosen"] if chosen_is_a else row["rejected"]
+    record_b = row["rejected"] if chosen_is_a else row["chosen"]
+    prompt = (
+        f"Given these two trajectories for the task '{row['prompt_task']}', evaluate "
+        "which one makes more progress towards the task. Return A for the first "
+        "trajectory and B for the second trajectory. Also predict the task progress "
+        "at each frame of the first trajectory, how far along the robot is towards "
+        "completing the task, a float between 0 and 1, where 0 is the starting state "
+        "and 1 is when the task is completed. If the robot is not performing the "
+        "same task, predict 0 progress."
+    )
+    content: list[dict] = [
+        {"type": "text", "text": prompt},
+        {"type": "text", "text": "This is Trajectory A. "},
+    ]
+    for image in load_images(record_a, processed_root):
+        content.append({"type": "image", "image": image})
+        content.append({"type": "text", "text": "<|prog_token|>"})
+    content.extend(
+        [
+            {"type": "text", "text": "<|split_token|>"},
+            {"type": "text", "text": "This is Trajectory B. "},
+        ]
+    )
+    for image in load_images(record_b, processed_root):
+        content.append({"type": "image", "image": image})
+        content.append({"type": "text", "text": "<|prog_token|>"})
+    content.extend(
+        [
+            {
+                "type": "text",
+                "text": "Now predict the preference between the two trajectories.",
+            },
+            {"type": "text", "text": "<|pref_token|>"},
+        ]
+    )
+    return [{"role": "user", "content": content}], record_a, float(chosen_is_a)
+
+
+def process_batch(processor, conversations: list[list[dict]]) -> dict[str, torch.Tensor]:
+    from qwen_vl_utils import process_vision_info
+
+    texts = [
+        processor.apply_chat_template(
+            message,
+            tokenize=False,
+            add_generation_prompt=False,
+            add_vision_id=True,
+            enable_thinking=False,
+            fps=1,
+        )
+        for message in conversations
+    ]
+    image_inputs, video_inputs, video_kwargs = process_vision_info(
+        conversations,
+        return_video_kwargs=True,
+        return_video_metadata=True,
+        image_patch_size=processor.image_processor.patch_size,
+    )
+    if video_inputs:
+        raise RuntimeError("Robometer-Low smoke requires multi-image mode, not video mode")
+    kwargs = dict(
+        text=texts,
+        images=image_inputs,
+        padding=True,
+        truncation=False,
+        return_tensors="pt",
+        do_resize=False,
+    )
+    if video_kwargs:
+        kwargs.update(video_kwargs)
+    return processor(**kwargs)
+
+
+def make_targets(records_a: list[dict], device: torch.device) -> dict[str, torch.Tensor]:
+    progress = torch.as_tensor(
+        np.asarray([record["target_progress"] for record in records_a]),
+        dtype=torch.float32,
+        device=device,
+    )
+    progress_mask = torch.as_tensor(
+        np.asarray(
+            [
+                np.asarray(record["frame_valid_mask"], dtype=bool)
+                & (np.asarray(record["predict_last_frame_mask"]) > 0)
+                & bool(record["progress_supervised"])
+                for record in records_a
+            ]
+        ),
+        dtype=torch.bool,
+        device=device,
+    )
+    success = torch.as_tensor(
+        np.asarray([record["success_label"] for record in records_a]),
+        dtype=torch.float32,
+        device=device,
+    )
+    success_mask = torch.as_tensor(
+        np.asarray([record["frame_valid_mask"] for record in records_a]),
+        dtype=torch.bool,
+        device=device,
+    )
+    return {
+        "progress": progress,
+        "progress_mask": progress_mask,
+        "success": success,
+        "success_mask": success_mask,
+    }
+
+
+def finite_grad_audit(named_parameters) -> tuple[bool, float, int]:
+    squared_norm = 0.0
+    tensor_count = 0
+    for _name, parameter in named_parameters:
+        if not parameter.requires_grad or parameter.grad is None:
+            continue
+        tensor_count += 1
+        gradient = parameter.grad.detach().float()
+        if not torch.isfinite(gradient).all():
+            return False, math.nan, tensor_count
+        squared_norm += float(torch.sum(gradient * gradient))
+    return True, math.sqrt(squared_norm), tensor_count
+
+
+def group_grad_norm(named_parameters, marker: str) -> float:
+    squared_norm = 0.0
+    found = 0
+    for name, parameter in named_parameters:
+        if marker not in name or parameter.grad is None:
+            continue
+        squared_norm += float(torch.sum(parameter.grad.detach().float() ** 2))
+        found += 1
+    return math.sqrt(squared_norm) if found else 0.0
+
+
+def main() -> None:
+    args = parse_args()
+    if args.micro_batch_pairs <= 0 or args.gradient_accumulation <= 0:
+        raise ValueError("batch and accumulation must be positive")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.cuda.manual_seed_all(args.seed)
+    torch.backends.cuda.matmul.allow_tf32 = True
+
+    from peft import LoraConfig, get_peft_model
+    from transformers import AutoModelForImageTextToText, AutoProcessor
+
+    started = time.perf_counter()
+    processor = AutoProcessor.from_pretrained(
+        args.snapshot, local_files_only=True, padding_side="right"
+    )
+    original_vocab = len(processor.tokenizer)
+    for token in SPECIAL_TOKENS:
+        if token not in processor.tokenizer.get_vocab():
+            processor.tokenizer.add_special_tokens(
+                {"additional_special_tokens": [token]}
+            )
+    special_token_ids = {
+        token: int(processor.tokenizer.convert_tokens_to_ids(token))
+        for token in SPECIAL_TOKENS
+    }
+    model = AutoModelForImageTextToText.from_pretrained(
+        args.snapshot,
+        local_files_only=True,
+        dtype=torch.bfloat16,
+        attn_implementation="flash_attention_2",
+        device_map={"": 0},
+    )
+    model.resize_token_embeddings(len(processor.tokenizer))
+    for parameter in model.parameters():
+        parameter.requires_grad_(False)
+
+    language_model = model.model.language_model
+    peft_config = LoraConfig(
+        r=8,
+        lora_alpha=16,
+        lora_dropout=0.05,
+        bias="none",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+        trainable_token_indices=list(special_token_ids.values()),
+    )
+    model.model.language_model = get_peft_model(language_model, peft_config)
+    model.config.use_cache = False
+    model.gradient_checkpointing_enable(
+        gradient_checkpointing_kwargs={"use_reentrant": False}
+    )
+    model.enable_input_require_grads()
+
+    hidden_size = int(model.config.text_config.hidden_size)
+    heads = RobometerHeads(hidden_size).to(device="cuda", dtype=torch.bfloat16)
+    backbone_trainable = [
+        parameter for parameter in model.parameters() if parameter.requires_grad
+    ]
+    head_parameters = list(heads.parameters())
+    optimizer = torch.optim.AdamW(
+        [
+            {"params": backbone_trainable, "lr": args.lora_lr},
+            {"params": head_parameters, "lr": args.head_lr},
+        ],
+        weight_decay=0.01,
+    )
+    rows = read_train_rows(args.manifest, args.pair_pool_size)
+    total_parameters = sum(parameter.numel() for parameter in model.parameters())
+    trainable_backbone_parameters = sum(p.numel() for p in backbone_trainable)
+    trainable_head_parameters = sum(p.numel() for p in head_parameters)
+
+    model.train()
+    heads.train()
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+    load_seconds = time.perf_counter() - started
+    run_started = time.perf_counter()
+    component_history = []
+    sequence_lengths = []
+    optimizer.zero_grad(set_to_none=True)
+    named_trainable = list(model.named_parameters()) + [
+        (f"heads.{name}", parameter) for name, parameter in heads.named_parameters()
+    ]
+
+    for optimizer_step in range(args.optimizer_steps):
+        for accumulation_index in range(args.gradient_accumulation):
+            global_microstep = (
+                optimizer_step * args.gradient_accumulation + accumulation_index
+            )
+            batch_rows = [
+                rows[(global_microstep * args.micro_batch_pairs + offset) % len(rows)]
+                for offset in range(args.micro_batch_pairs)
+            ]
+            conversations = []
+            records_a = []
+            preference_labels = []
+            for offset, row in enumerate(batch_rows):
+                chosen_is_a = ((global_microstep * args.micro_batch_pairs + offset) % 2) == 0
+                conversation, record_a, label = build_conversation(
+                    row, args.processed_root, chosen_is_a
+                )
+                conversations.append(conversation)
+                records_a.append(record_a)
+                preference_labels.append(label)
+            inputs = process_batch(processor, conversations)
+            sequence_lengths.extend(inputs["attention_mask"].sum(1).tolist())
+            inputs = {key: value.to("cuda") for key, value in inputs.items()}
+            targets = make_targets(records_a, torch.device("cuda"))
+            preference_target = torch.tensor(
+                preference_labels, dtype=torch.float32, device="cuda"
+            )
+            output = model.model(**inputs, output_hidden_states=False, use_cache=False)
+            hidden = output.last_hidden_state
+            prog_mask = inputs["input_ids"].eq(special_token_ids["<|prog_token|>"])
+            pref_mask = inputs["input_ids"].eq(special_token_ids["<|pref_token|>"])
+            prog_counts = prog_mask.sum(1)
+            pref_counts = pref_mask.sum(1)
+            if not torch.equal(
+                prog_counts, torch.full_like(prog_counts, 16)
+            ) or not torch.equal(pref_counts, torch.ones_like(pref_counts)):
+                raise RuntimeError(
+                    f"token extraction mismatch: prog={prog_counts.tolist()} "
+                    f"pref={pref_counts.tolist()}"
+                )
+            prog_hidden = hidden[prog_mask].reshape(args.micro_batch_pairs, 16, hidden_size)
+            pref_hidden = hidden[pref_mask].reshape(args.micro_batch_pairs, hidden_size)
+            progress_logits = heads.progress_head(prog_hidden[:, :8])
+            success_logits = heads.success_head(prog_hidden[:, :8]).squeeze(-1)
+            preference_logits = heads.preference_head(pref_hidden).squeeze(-1)
+
+            if targets["progress_mask"].any():
+                per_frame_progress = -(
+                    targets["progress"] * F.log_softmax(progress_logits.float(), dim=-1)
+                ).sum(-1)
+                progress_loss = per_frame_progress[targets["progress_mask"]].mean()
+            else:
+                progress_loss = progress_logits.float().sum() * 0.0
+            valid_success = targets["success"][targets["success_mask"]]
+            valid_success_logits = success_logits.float()[targets["success_mask"]]
+            positives = valid_success.sum()
+            negatives = valid_success.numel() - positives
+            pos_weight = (negatives / positives.clamp_min(1.0)).clamp_min(1.0)
+            success_loss = F.binary_cross_entropy_with_logits(
+                valid_success_logits, valid_success, pos_weight=pos_weight
+            )
+            preference_loss = F.binary_cross_entropy_with_logits(
+                preference_logits.float(), preference_target
+            )
+            total_loss = progress_loss + success_loss + preference_loss
+            if not torch.isfinite(total_loss):
+                raise FloatingPointError(f"non-finite loss: {float(total_loss)}")
+            (total_loss / args.gradient_accumulation).backward()
+            component_history.append(
+                {
+                    "total": float(total_loss.detach()),
+                    "preference": float(preference_loss.detach()),
+                    "progress": float(progress_loss.detach()),
+                    "success": float(success_loss.detach()),
+                    "progress_supervised_frames": int(targets["progress_mask"].sum()),
+                    "success_supervised_frames": int(targets["success_mask"].sum()),
+                }
+            )
+
+        finite_gradients, preclip_grad_norm, gradient_tensor_count = finite_grad_audit(
+            named_trainable
+        )
+        if not finite_gradients:
+            raise FloatingPointError("non-finite trainable gradient")
+        grad_groups = {
+            "lora": group_grad_norm(named_trainable, "lora_"),
+            "token_rows": group_grad_norm(named_trainable, "trainable_tokens"),
+            "progress_head": group_grad_norm(named_trainable, "heads.progress_head"),
+            "success_head": group_grad_norm(named_trainable, "heads.success_head"),
+            "preference_head": group_grad_norm(named_trainable, "heads.preference_head"),
+        }
+        missing_grad_groups = [name for name, value in grad_groups.items() if not value > 0]
+        if missing_grad_groups:
+            raise RuntimeError(f"missing gradient groups: {missing_grad_groups}")
+        torch.nn.utils.clip_grad_norm_(backbone_trainable + head_parameters, 1.0)
+        optimizer.step()
+        optimizer.zero_grad(set_to_none=True)
+
+    torch.cuda.synchronize()
+    run_seconds = time.perf_counter() - run_started
+    device = torch.cuda.get_device_properties(0)
+    peak_allocated = torch.cuda.max_memory_allocated()
+    peak_reserved = torch.cuda.max_memory_reserved()
+    effective_batch = args.micro_batch_pairs * args.gradient_accumulation
+    payload = {
+        "status": "pass",
+        "protocol_id": "phase21a_robometer_low_smoke_v1",
+        "scope": {
+            "smoke_only": True,
+            "formal_training_started": False,
+            "cosmos3_edge_modified": False,
+        },
+        "micro_batch_pairs": args.micro_batch_pairs,
+        "gradient_accumulation": args.gradient_accumulation,
+        "effective_batch_pairs": effective_batch,
+        "optimizer_steps": args.optimizer_steps,
+        "microsteps": args.optimizer_steps * args.gradient_accumulation,
+        "real_pair_pool_size": len(rows),
+        "pair_pool_selection": "longest_prompt_characters_in_train_split",
+        "pair_pool_prompt_character_range": [
+            min(len(row["prompt_task"]) for row in rows),
+            max(len(row["prompt_task"]) for row in rows),
+        ],
+        "frames_per_pair": 16,
+        "precision": "BF16",
+        "gradient_checkpointing": True,
+        "architecture": {
+            "joint_a_b_forward": True,
+            "direct_preference_token_head": True,
+            "per_frame_progress_tokens": True,
+            "progress_bins": 10,
+            "lora_rank": 8,
+            "lora_alpha": 16,
+            "lora_targets": ["q_proj", "k_proj", "v_proj", "o_proj"],
+            "special_tokens": special_token_ids,
+            "original_vocab_size": original_vocab,
+            "resized_vocab_size": len(processor.tokenizer),
+        },
+        "parameters": {
+            "base_total": total_parameters,
+            "backbone_trainable_lora_and_token_rows": trainable_backbone_parameters,
+            "heads_trainable": trainable_head_parameters,
+            "all_trainable": trainable_backbone_parameters + trainable_head_parameters,
+        },
+        "loss_last": component_history[-1],
+        "loss_all_finite": all(
+            math.isfinite(value)
+            for item in component_history
+            for key, value in item.items()
+            if key in {"total", "preference", "progress", "success"}
+        ),
+        "gradient_audit": {
+            "finite": finite_gradients,
+            "preclip_global_norm": preclip_grad_norm,
+            "tensor_count": gradient_tensor_count,
+            "group_norms": grad_groups,
+        },
+        "sequence_tokens": {
+            "min": int(min(sequence_lengths)),
+            "max": int(max(sequence_lengths)),
+            "mean": float(np.mean(sequence_lengths)),
+        },
+        "timing": {
+            "model_load_seconds": load_seconds,
+            "run_seconds": run_seconds,
+            "seconds_per_microstep": run_seconds
+            / (args.optimizer_steps * args.gradient_accumulation),
+            "pairs_per_second": effective_batch * args.optimizer_steps / run_seconds,
+        },
+        "gpu": {
+            "name": device.name,
+            "total_gib": device.total_memory / 2**30,
+            "peak_allocated_gib": peak_allocated / 2**30,
+            "peak_reserved_gib": peak_reserved / 2**30,
+            "peak_reserved_fraction": peak_reserved / device.total_memory,
+        },
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(payload, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/smoke_phase21a_robometer_low_full.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+"""Single-GPU full-language-decoder Robometer-Low smoke on real pairs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import random
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+EXPERIMENT_ROOT = Path(__file__).resolve().parents[1]
+if str(EXPERIMENT_ROOT) not in sys.path:
+    sys.path.insert(0, str(EXPERIMENT_ROOT))
+
+from scripts.smoke_phase21a_robometer_low import (  # noqa: E402
+    SPECIAL_TOKENS,
+    RobometerHeads,
+    build_conversation,
+    finite_grad_audit,
+    group_grad_norm,
+    make_targets,
+    process_batch,
+    read_train_rows,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--snapshot", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--processed-root", type=Path, required=True)
+    parser.add_argument("--micro-batch-pairs", type=int, required=True)
+    parser.add_argument("--gradient-accumulation", type=int, required=True)
+    parser.add_argument("--optimizer-steps", type=int, default=1)
+    parser.add_argument("--pair-pool-size", type=int, default=8)
+    parser.add_argument("--optimizer", choices=("adamw_torch", "paged_adamw_8bit"), required=True)
+    parser.add_argument("--learning-rate", type=float, default=2.0e-5)
+    parser.add_argument("--seed", type=int, default=7)
+    parser.add_argument("--require-all-gradient-groups", action="store_true")
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def tensor_bytes(value) -> tuple[int, int]:
+    """Return CUDA and CPU tensor bytes recursively for optimizer state."""
+    cuda_bytes = 0
+    cpu_bytes = 0
+    if torch.is_tensor(value):
+        size = value.numel() * value.element_size()
+        if value.device.type == "cuda":
+            cuda_bytes += size
+        elif value.device.type == "cpu":
+            cpu_bytes += size
+    elif isinstance(value, dict):
+        for item in value.values():
+            cuda, cpu = tensor_bytes(item)
+            cuda_bytes += cuda
+            cpu_bytes += cpu
+    elif isinstance(value, (list, tuple)):
+        for item in value:
+            cuda, cpu = tensor_bytes(item)
+            cuda_bytes += cuda
+            cpu_bytes += cpu
+    return cuda_bytes, cpu_bytes
+
+
+def make_optimizer(name: str, parameters: list[torch.nn.Parameter], learning_rate: float):
+    if name == "adamw_torch":
+        return torch.optim.AdamW(
+            parameters,
+            lr=learning_rate,
+            weight_decay=0.01,
+            foreach=False,
+        )
+    import bitsandbytes as bnb
+
+    return bnb.optim.PagedAdamW8bit(
+        parameters,
+        lr=learning_rate,
+        weight_decay=0.01,
+        min_8bit_size=4096,
+    )
+
+
+def main() -> None:
+    args = parse_args()
+    if args.micro_batch_pairs <= 0 or args.gradient_accumulation <= 0:
+        raise ValueError("batch and accumulation must be positive")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.cuda.manual_seed_all(args.seed)
+    torch.backends.cuda.matmul.allow_tf32 = True
+
+    from transformers import AutoModelForImageTextToText, AutoProcessor
+
+    started = time.perf_counter()
+    processor = AutoProcessor.from_pretrained(
+        args.snapshot, local_files_only=True, padding_side="right"
+    )
+    original_vocab = len(processor.tokenizer)
+    for token in SPECIAL_TOKENS:
+        if token not in processor.tokenizer.get_vocab():
+            processor.tokenizer.add_special_tokens({"additional_special_tokens": [token]})
+    special_token_ids = {
+        token: int(processor.tokenizer.convert_tokens_to_ids(token))
+        for token in SPECIAL_TOKENS
+    }
+    model = AutoModelForImageTextToText.from_pretrained(
+        args.snapshot,
+        local_files_only=True,
+        dtype=torch.bfloat16,
+        attn_implementation="flash_attention_2",
+        device_map={"": 0},
+    )
+    model.resize_token_embeddings(len(processor.tokenizer))
+    for parameter in model.parameters():
+        parameter.requires_grad_(False)
+    for parameter in model.model.language_model.parameters():
+        parameter.requires_grad_(True)
+    model.config.use_cache = False
+    model.gradient_checkpointing_enable(
+        gradient_checkpointing_kwargs={"use_reentrant": False}
+    )
+    model.enable_input_require_grads()
+
+    hidden_size = int(model.config.text_config.hidden_size)
+    heads = RobometerHeads(hidden_size).to(device="cuda", dtype=torch.bfloat16)
+    language_parameters = [
+        parameter for parameter in model.parameters() if parameter.requires_grad
+    ]
+    head_parameters = list(heads.parameters())
+    trainable_parameters = language_parameters + head_parameters
+    vision_trainable = sum(
+        parameter.numel()
+        for name, parameter in model.named_parameters()
+        if parameter.requires_grad and ".visual." in name
+    )
+    if vision_trainable:
+        raise RuntimeError(f"vision boundary violation: {vision_trainable} trainable parameters")
+    optimizer = make_optimizer(args.optimizer, trainable_parameters, args.learning_rate)
+    rows = read_train_rows(args.manifest, args.pair_pool_size)
+
+    model.train()
+    heads.train()
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+    load_seconds = time.perf_counter() - started
+    run_started = time.perf_counter()
+    component_history = []
+    sequence_lengths = []
+    optimizer.zero_grad(set_to_none=True)
+    named_trainable = list(model.named_parameters()) + [
+        (f"heads.{name}", parameter) for name, parameter in heads.named_parameters()
+    ]
+    last_gradient_audit = None
+
+    for optimizer_step in range(args.optimizer_steps):
+        for accumulation_index in range(args.gradient_accumulation):
+            global_microstep = optimizer_step * args.gradient_accumulation + accumulation_index
+            batch_rows = [
+                rows[(global_microstep * args.micro_batch_pairs + offset) % len(rows)]
+                for offset in range(args.micro_batch_pairs)
+            ]
+            conversations = []
+            records_a = []
+            preference_labels = []
+            for offset, row in enumerate(batch_rows):
+                chosen_is_a = ((global_microstep * args.micro_batch_pairs + offset) % 2) == 0
+                conversation, record_a, label = build_conversation(
+                    row, args.processed_root, chosen_is_a
+                )
+                conversations.append(conversation)
+                records_a.append(record_a)
+                preference_labels.append(label)
+            inputs = process_batch(processor, conversations)
+            sequence_lengths.extend(inputs["attention_mask"].sum(1).tolist())
+            inputs = {key: value.to("cuda") for key, value in inputs.items()}
+            targets = make_targets(records_a, torch.device("cuda"))
+            preference_target = torch.tensor(
+                preference_labels, dtype=torch.float32, device="cuda"
+            )
+            output = model.model(**inputs, output_hidden_states=False, use_cache=False)
+            hidden = output.last_hidden_state
+            prog_mask = inputs["input_ids"].eq(special_token_ids["<|prog_token|>"])
+            pref_mask = inputs["input_ids"].eq(special_token_ids["<|pref_token|>"])
+            prog_counts = prog_mask.sum(1)
+            pref_counts = pref_mask.sum(1)
+            if not torch.equal(prog_counts, torch.full_like(prog_counts, 16)):
+                raise RuntimeError(f"progress token counts: {prog_counts.tolist()}")
+            if not torch.equal(pref_counts, torch.ones_like(pref_counts)):
+                raise RuntimeError(f"preference token counts: {pref_counts.tolist()}")
+            prog_hidden = hidden[prog_mask].reshape(args.micro_batch_pairs, 16, hidden_size)
+            pref_hidden = hidden[pref_mask].reshape(args.micro_batch_pairs, hidden_size)
+            progress_logits = heads.progress_head(prog_hidden[:, :8])
+            success_logits = heads.success_head(prog_hidden[:, :8]).squeeze(-1)
+            preference_logits = heads.preference_head(pref_hidden).squeeze(-1)
+
+            if targets["progress_mask"].any():
+                per_frame_progress = -(
+                    targets["progress"] * F.log_softmax(progress_logits.float(), dim=-1)
+                ).sum(-1)
+                progress_loss = per_frame_progress[targets["progress_mask"]].mean()
+            else:
+                progress_loss = progress_logits.float().sum() * 0.0
+            valid_success = targets["success"][targets["success_mask"]]
+            valid_success_logits = success_logits.float()[targets["success_mask"]]
+            positives = valid_success.sum()
+            negatives = valid_success.numel() - positives
+            pos_weight = (negatives / positives.clamp_min(1.0)).clamp_min(1.0)
+            success_loss = F.binary_cross_entropy_with_logits(
+                valid_success_logits, valid_success, pos_weight=pos_weight
+            )
+            preference_loss = F.binary_cross_entropy_with_logits(
+                preference_logits.float(), preference_target
+            )
+            total_loss = progress_loss + success_loss + preference_loss
+            if not torch.isfinite(total_loss):
+                raise FloatingPointError(f"non-finite loss: {float(total_loss)}")
+            (total_loss / args.gradient_accumulation).backward()
+            component_history.append(
+                {
+                    "total": float(total_loss.detach()),
+                    "preference": float(preference_loss.detach()),
+                    "progress": float(progress_loss.detach()),
+                    "success": float(success_loss.detach()),
+                    "progress_supervised_frames": int(targets["progress_mask"].sum()),
+                    "success_supervised_frames": int(targets["success_mask"].sum()),
+                }
+            )
+
+        finite_gradients, preclip_grad_norm, gradient_tensor_count = finite_grad_audit(
+            named_trainable
+        )
+        if not finite_gradients:
+            raise FloatingPointError("non-finite trainable gradient")
+        embedding_gradient = model.get_input_embeddings().weight.grad
+        if embedding_gradient is None:
+            special_token_grad_norm = 0.0
+        else:
+            special_token_grad_norm = float(
+                torch.linalg.vector_norm(
+                    embedding_gradient[list(special_token_ids.values())].float()
+                )
+            )
+        grad_groups = {
+            "language_decoder": group_grad_norm(named_trainable, "language_model"),
+            "special_token_rows": special_token_grad_norm,
+            "progress_head": group_grad_norm(named_trainable, "heads.progress_head"),
+            "success_head": group_grad_norm(named_trainable, "heads.success_head"),
+            "preference_head": group_grad_norm(named_trainable, "heads.preference_head"),
+        }
+        missing_grad_groups = [name for name, value in grad_groups.items() if not value > 0]
+        if args.require_all_gradient_groups and missing_grad_groups:
+            raise RuntimeError(f"missing gradient groups: {missing_grad_groups}")
+        last_gradient_audit = {
+            "finite": finite_gradients,
+            "preclip_global_norm": preclip_grad_norm,
+            "tensor_count": gradient_tensor_count,
+            "group_norms": grad_groups,
+            "missing_groups": missing_grad_groups,
+        }
+        torch.nn.utils.clip_grad_norm_(trainable_parameters, 10.0)
+        optimizer.step()
+        optimizer.zero_grad(set_to_none=True)
+
+    torch.cuda.synchronize()
+    run_seconds = time.perf_counter() - run_started
+    device = torch.cuda.get_device_properties(0)
+    peak_allocated = torch.cuda.max_memory_allocated()
+    peak_reserved = torch.cuda.max_memory_reserved()
+    optimizer_cuda_bytes, optimizer_cpu_bytes = tensor_bytes(optimizer.state)
+    effective_batch = args.micro_batch_pairs * args.gradient_accumulation
+    language_trainable_count = sum(parameter.numel() for parameter in language_parameters)
+    head_trainable_count = sum(parameter.numel() for parameter in head_parameters)
+    payload = {
+        "status": "pass",
+        "protocol_id": "phase21a_robometer_low_full_smoke_v1",
+        "scope": {
+            "smoke_only": True,
+            "formal_training_started": False,
+            "cosmos3_edge_modified": False,
+        },
+        "micro_batch_pairs": args.micro_batch_pairs,
+        "gradient_accumulation": args.gradient_accumulation,
+        "effective_batch_pairs": effective_batch,
+        "optimizer_steps": args.optimizer_steps,
+        "microsteps": args.optimizer_steps * args.gradient_accumulation,
+        "optimizer": args.optimizer,
+        "optimizer_official_default": args.optimizer == "adamw_torch",
+        "real_pair_pool_size": len(rows),
+        "pair_pool_selection": "longest_prompt_characters_in_train_split",
+        "pair_pool_prompt_character_range": [
+            min(len(row["prompt_task"]) for row in rows),
+            max(len(row["prompt_task"]) for row in rows),
+        ],
+        "frames_per_pair": 16,
+        "precision": "BF16",
+        "gradient_checkpointing": True,
+        "architecture": {
+            "joint_a_b_forward": True,
+            "vision_frozen": True,
+            "language_decoder_full_tune": True,
+            "peft_or_lora": False,
+            "direct_preference_token_head": True,
+            "per_frame_progress_tokens": True,
+            "progress_bins": 10,
+            "special_tokens": special_token_ids,
+            "original_vocab_size": original_vocab,
+            "resized_vocab_size": len(processor.tokenizer),
+        },
+        "parameters": {
+            "model_total": sum(parameter.numel() for parameter in model.parameters()),
+            "language_decoder_trainable": language_trainable_count,
+            "heads_trainable": head_trainable_count,
+            "all_trainable": language_trainable_count + head_trainable_count,
+            "vision_trainable": vision_trainable,
+            "trainable_fraction_of_model_and_heads": (
+                (language_trainable_count + head_trainable_count)
+                / (sum(parameter.numel() for parameter in model.parameters()) + head_trainable_count)
+            ),
+        },
+        "optimizer_state": {
+            "cuda_gib": optimizer_cuda_bytes / 2**30,
+            "cpu_gib": optimizer_cpu_bytes / 2**30,
+        },
+        "loss_last": component_history[-1],
+        "loss_all_finite": all(
+            math.isfinite(value)
+            for item in component_history
+            for key, value in item.items()
+            if key in {"total", "preference", "progress", "success"}
+        ),
+        "gradient_audit": last_gradient_audit,
+        "sequence_tokens": {
+            "min": int(min(sequence_lengths)),
+            "max": int(max(sequence_lengths)),
+            "mean": float(np.mean(sequence_lengths)),
+        },
+        "timing": {
+            "model_load_seconds": load_seconds,
+            "run_seconds": run_seconds,
+            "seconds_per_microstep": run_seconds
+            / (args.optimizer_steps * args.gradient_accumulation),
+            "pairs_per_second": effective_batch * args.optimizer_steps / run_seconds,
+        },
+        "gpu": {
+            "name": device.name,
+            "total_gib": device.total_memory / 2**30,
+            "peak_allocated_gib": peak_allocated / 2**30,
+            "peak_reserved_gib": peak_reserved / 2**30,
+            "peak_reserved_fraction": peak_reserved / device.total_memory,
+        },
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(payload, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_phase21a_robometer_low_lora.py

@@ -0,0 +1,519 @@
+#!/usr/bin/env python3
+"""Resumable formal Robometer-Low-LoRA training on joint preference pairs."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import random
+import sys
+import time
+from pathlib import Path
+
+# Avoid large reserved-but-unallocated CUDA segments on near-capacity batches.
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+EXPERIMENT_ROOT = Path(__file__).resolve().parents[1]
+if str(EXPERIMENT_ROOT) not in sys.path:
+    sys.path.insert(0, str(EXPERIMENT_ROOT))
+
+from scripts.smoke_phase21a_robometer_low import (  # noqa: E402
+    SPECIAL_TOKENS,
+    RobometerHeads,
+    build_conversation,
+    finite_grad_audit,
+    group_grad_norm,
+    make_targets,
+    process_batch,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--snapshot", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--processed-root", type=Path, required=True)
+    parser.add_argument("--seed", type=int, required=True)
+    parser.add_argument("--optimizer-steps", type=int, default=3000)
+    parser.add_argument("--micro-batch-pairs", type=int, default=32)
+    parser.add_argument("--gradient-accumulation", type=int, default=2)
+    parser.add_argument("--lora-lr", type=float, default=2.0e-6)
+    parser.add_argument("--head-lr", type=float, default=1.0e-4)
+    parser.add_argument("--checkpoint-every", type=int, default=250)
+    parser.add_argument("--eval-every", type=int, default=250)
+    parser.add_argument("--eval-micro-batch-pairs", type=int, default=32)
+    parser.add_argument("--early-stop-min-steps", type=int, default=1000)
+    parser.add_argument("--early-stop-patience-evals", type=int, default=4)
+    parser.add_argument("--early-stop-min-delta", type=float, default=5.0e-3)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--resume", action="store_true")
+    return parser.parse_args()
+
+
+def read_rows(path: Path) -> list[dict]:
+    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+    train = [row for row in rows if row["split"] == "train" and row["sample_type"] == "preference"]
+    if len(train) != 2021:
+        raise RuntimeError(f"expected 2021 train preference pairs, found {len(train)}")
+    return train
+
+
+def read_dev_rows(path: Path) -> list[dict]:
+    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+    dev = [row for row in rows if row["split"] == "dev" and row["sample_type"] == "preference"]
+    if len(dev) != 108:
+        raise RuntimeError(f"expected 108 ID-dev preference pairs, found {len(dev)}")
+    return dev
+
+
+def global_success_pos_weight(rows: list[dict]) -> float:
+    positive = 0.0
+    total = 0
+    for row in rows:
+        for role in ("chosen", "rejected"):
+            record = row[role]
+            valid = np.asarray(record["frame_valid_mask"], dtype=bool)
+            labels = np.asarray(record["success_label"], dtype=np.float32)
+            positive += float(labels[valid].sum())
+            total += int(valid.sum())
+    if not 0 < positive < total:
+        raise RuntimeError("success labels require both classes")
+    return (total - positive) / positive
+
+
+def atomic_torch_save(payload: dict, path: Path) -> None:
+    temporary = path.with_suffix(".tmp")
+    torch.save(payload, temporary)
+    temporary.replace(path)
+
+
+def reconcile_progress_log(path: Path, completed_steps: int) -> None:
+    """Drop records newer than the checkpoint before a resumed run appends."""
+    if not path.is_file():
+        return
+    records = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+    retained = [record for record in records if int(record["step"]) <= completed_steps]
+    temporary = path.with_suffix(".tmp")
+    payload = "".join(json.dumps(record, sort_keys=True) + "\n" for record in retained)
+    temporary.write_text(payload, encoding="utf-8")
+    temporary.replace(path)
+
+
+def cpu_state_dict(state: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
+    return {name: tensor.detach().cpu().clone() for name, tensor in state.items()}
+
+
+@torch.inference_mode()
+def evaluate_dev(
+    *, model, processor, heads, rows: list[dict], processed_root: Path,
+    token_ids: dict[str, int], hidden_size: int, pos_weight: torch.Tensor,
+    micro_batch_pairs: int,
+) -> dict:
+    """Evaluate both A/B orientations on the frozen ID-dev split only."""
+    model.eval()
+    heads.eval()
+    presentations = [(row, chosen_is_a) for row in rows for chosen_is_a in (True, False)]
+    sums = {"preference": 0.0, "progress": 0.0, "success": 0.0}
+    counts = {"preference": 0, "progress": 0, "success": 0}
+    preference_correct = 0
+    for start in range(0, len(presentations), micro_batch_pairs):
+        batch = presentations[start : start + micro_batch_pairs]
+        conversations, records_a, preference_labels = [], [], []
+        for row, chosen_is_a in batch:
+            conversation, record_a, label = build_conversation(row, processed_root, chosen_is_a)
+            conversations.append(conversation)
+            records_a.append(record_a)
+            preference_labels.append(label)
+        inputs = process_batch(processor, conversations)
+        inputs = {key: value.to("cuda") for key, value in inputs.items()}
+        targets = make_targets(records_a, torch.device("cuda"))
+        preference_target = torch.tensor(preference_labels, dtype=torch.float32, device="cuda")
+        output = model.model(**inputs, output_hidden_states=False, use_cache=False)
+        hidden = output.last_hidden_state
+        prog_mask = inputs["input_ids"].eq(token_ids["<|prog_token|>"])
+        pref_mask = inputs["input_ids"].eq(token_ids["<|pref_token|>"])
+        batch_size = len(batch)
+        if not torch.equal(prog_mask.sum(1), torch.full_like(prog_mask.sum(1), 16)):
+            raise RuntimeError("ID-dev progress token extraction mismatch")
+        if not torch.equal(pref_mask.sum(1), torch.ones_like(pref_mask.sum(1))):
+            raise RuntimeError("ID-dev preference token extraction mismatch")
+        prog_hidden = hidden[prog_mask].reshape(batch_size, 16, hidden_size)
+        pref_hidden = hidden[pref_mask].reshape(batch_size, hidden_size)
+        progress_logits = heads.progress_head(prog_hidden[:, :8])
+        success_logits = heads.success_head(prog_hidden[:, :8]).squeeze(-1)
+        preference_logits = heads.preference_head(pref_hidden).squeeze(-1)
+        progress_frames = -(
+            targets["progress"] * F.log_softmax(progress_logits.float(), dim=-1)
+        ).sum(-1)
+        progress_values = progress_frames[targets["progress_mask"]]
+        success_sum = F.binary_cross_entropy_with_logits(
+            success_logits.float()[targets["success_mask"]],
+            targets["success"][targets["success_mask"]],
+            pos_weight=pos_weight,
+            reduction="sum",
+        )
+        preference_sum = F.binary_cross_entropy_with_logits(
+            preference_logits.float(), preference_target, reduction="sum"
+        )
+        sums["progress"] += float(progress_values.sum())
+        sums["success"] += float(success_sum)
+        sums["preference"] += float(preference_sum)
+        counts["progress"] += int(progress_values.numel())
+        counts["success"] += int(targets["success_mask"].sum())
+        counts["preference"] += batch_size
+        preference_correct += int(
+            ((preference_logits > 0) == (preference_target > 0.5)).sum()
+        )
+    components = {name: sums[name] / counts[name] for name in sums}
+    model.train()
+    heads.train()
+    return {
+        "loss": sum(components.values()),
+        "loss_components": components,
+        "preference_accuracy": preference_correct / counts["preference"],
+        "pair_count": len(rows),
+        "orientation_presentations": len(presentations),
+        "supervision_counts": counts,
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    if args.micro_batch_pairs * args.gradient_accumulation != 64:
+        raise ValueError("formal protocol requires exact effective batch 64")
+    if min(args.optimizer_steps, args.checkpoint_every, args.eval_every) <= 0:
+        raise ValueError("steps, checkpoint interval, and eval interval must be positive")
+    if args.eval_micro_batch_pairs <= 0 or args.early_stop_patience_evals <= 0:
+        raise ValueError("eval batch and early-stop patience must be positive")
+    if not 0 < args.early_stop_min_steps <= args.optimizer_steps:
+        raise ValueError("early-stop minimum must be in (0, optimizer_steps]")
+    if args.checkpoint_every != args.eval_every:
+        raise ValueError("v2 requires checkpoint_every == eval_every")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.cuda.manual_seed_all(args.seed)
+    torch.backends.cuda.matmul.allow_tf32 = True
+
+    from peft import LoraConfig, get_peft_model, get_peft_model_state_dict, set_peft_model_state_dict
+    from transformers import AutoModelForImageTextToText, AutoProcessor
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    progress_path = args.output_dir / "progress.jsonl"
+    checkpoint_path = args.output_dir / "latest_training_state.pt"
+    best_model_path = args.output_dir / "best_model_state.pt"
+    eval_path = args.output_dir / "id_dev_metrics.jsonl"
+    manifest_sha256 = hashlib.sha256(args.manifest.read_bytes()).hexdigest()
+    rows = read_rows(args.manifest)
+    dev_rows = read_dev_rows(args.manifest)
+    processor = AutoProcessor.from_pretrained(args.snapshot, local_files_only=True, padding_side="right")
+    for token in SPECIAL_TOKENS:
+        if token not in processor.tokenizer.get_vocab():
+            processor.tokenizer.add_special_tokens({"additional_special_tokens": [token]})
+    token_ids = {token: int(processor.tokenizer.convert_tokens_to_ids(token)) for token in SPECIAL_TOKENS}
+    model = AutoModelForImageTextToText.from_pretrained(
+        args.snapshot,
+        local_files_only=True,
+        dtype=torch.bfloat16,
+        attn_implementation="flash_attention_2",
+        device_map={"": 0},
+    )
+    model.resize_token_embeddings(len(processor.tokenizer))
+    for parameter in model.parameters():
+        parameter.requires_grad_(False)
+    model.model.language_model = get_peft_model(
+        model.model.language_model,
+        LoraConfig(
+            r=8,
+            lora_alpha=16,
+            lora_dropout=0.05,
+            bias="none",
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+            trainable_token_indices=list(token_ids.values()),
+        ),
+    )
+    model.config.use_cache = False
+    model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
+    model.enable_input_require_grads()
+    hidden_size = int(model.config.text_config.hidden_size)
+    heads = RobometerHeads(hidden_size).to(device="cuda", dtype=torch.bfloat16)
+    backbone_parameters = [parameter for parameter in model.parameters() if parameter.requires_grad]
+    head_parameters = list(heads.parameters())
+    optimizer = torch.optim.AdamW(
+        [
+            {"params": backbone_parameters, "lr": args.lora_lr},
+            {"params": head_parameters, "lr": args.head_lr},
+        ],
+        weight_decay=0.01,
+    )
+    warmup_steps = max(1, round(args.optimizer_steps * 0.05))
+
+    def lr_lambda(step: int) -> float:
+        if step < warmup_steps:
+            return (step + 1) / warmup_steps
+        progress = (step - warmup_steps) / max(1, args.optimizer_steps - warmup_steps)
+        return 0.5 * (1.0 + math.cos(math.pi * progress))
+
+    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+    generator = np.random.default_rng(args.seed)
+    order = generator.permutation(len(rows)).tolist()
+    cursor = 0
+    start_step = 0
+    step_seconds: list[float] = []
+    eval_history: list[dict] = []
+    best_eval_loss = math.inf
+    best_step = 0
+    bad_eval_count = 0
+    pos_weight = torch.tensor(global_success_pos_weight(rows), dtype=torch.float32, device="cuda")
+
+    if args.resume:
+        if not checkpoint_path.is_file():
+            raise FileNotFoundError(checkpoint_path)
+        checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+        if checkpoint.get("protocol_id") != "phase21a_robometer_low_lora_train_v2":
+            raise RuntimeError("refusing to resume a checkpoint from a different protocol")
+        if checkpoint["manifest_sha256"] != manifest_sha256 or checkpoint["seed"] != args.seed:
+            raise RuntimeError("resume manifest or seed mismatch")
+        set_peft_model_state_dict(model.model.language_model, checkpoint["adapter_state"])
+        heads.load_state_dict(checkpoint["heads_state"])
+        optimizer.load_state_dict(checkpoint["optimizer_state"])
+        scheduler.load_state_dict(checkpoint["scheduler_state"])
+        generator.bit_generator.state = checkpoint["numpy_generator_state"]
+        order = checkpoint["order"]
+        cursor = checkpoint["cursor"]
+        start_step = checkpoint["completed_steps"]
+        step_seconds = checkpoint["step_seconds"]
+        eval_history = checkpoint.get("eval_history", [])
+        best_eval_loss = float(checkpoint.get("best_eval_loss", math.inf))
+        best_step = int(checkpoint.get("best_step", 0))
+        bad_eval_count = int(checkpoint.get("bad_eval_count", 0))
+        torch.set_rng_state(checkpoint["torch_rng_state"])
+        torch.cuda.set_rng_state_all(checkpoint["cuda_rng_state_all"])
+        reconcile_progress_log(progress_path, start_step)
+        reconcile_progress_log(eval_path, start_step)
+        if start_step >= args.optimizer_steps:
+            print(json.dumps({"status": "already_complete", "completed_steps": start_step}), flush=True)
+            return
+
+    model.train()
+    heads.train()
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+    named_trainable = list(model.named_parameters()) + [
+        (f"heads.{name}", parameter) for name, parameter in heads.named_parameters()
+    ]
+    completed = start_step
+    stop_reason = "max_steps"
+    for step in range(start_step, args.optimizer_steps):
+        if cursor + 64 > len(order):
+            order = generator.permutation(len(rows)).tolist()
+            cursor = 0
+        selected_indices = order[cursor : cursor + 64]
+        cursor += 64
+        selected_rows = [rows[index] for index in selected_indices]
+        optimizer.zero_grad(set_to_none=True)
+        components = {"preference": 0.0, "progress": 0.0, "success": 0.0}
+        sequence_min = 10**9
+        sequence_max = 0
+        torch.cuda.synchronize()
+        step_started = time.perf_counter()
+        for microstep in range(args.gradient_accumulation):
+            batch_rows = selected_rows[
+                microstep * args.micro_batch_pairs : (microstep + 1) * args.micro_batch_pairs
+            ]
+            conversations = []
+            records_a = []
+            preference_labels = []
+            for offset, row in enumerate(batch_rows):
+                global_presentation = step * 64 + microstep * args.micro_batch_pairs + offset
+                chosen_is_a = global_presentation % 2 == 0
+                conversation, record_a, label = build_conversation(row, args.processed_root, chosen_is_a)
+                conversations.append(conversation)
+                records_a.append(record_a)
+                preference_labels.append(label)
+            inputs = process_batch(processor, conversations)
+            lengths = inputs["attention_mask"].sum(1)
+            sequence_min = min(sequence_min, int(lengths.min()))
+            sequence_max = max(sequence_max, int(lengths.max()))
+            inputs = {key: value.to("cuda") for key, value in inputs.items()}
+            targets = make_targets(records_a, torch.device("cuda"))
+            preference_target = torch.tensor(preference_labels, dtype=torch.float32, device="cuda")
+            output = model.model(**inputs, output_hidden_states=False, use_cache=False)
+            hidden = output.last_hidden_state
+            prog_mask = inputs["input_ids"].eq(token_ids["<|prog_token|>"])
+            pref_mask = inputs["input_ids"].eq(token_ids["<|pref_token|>"])
+            if not torch.equal(prog_mask.sum(1), torch.full_like(prog_mask.sum(1), 16)):
+                raise RuntimeError("progress token extraction mismatch")
+            if not torch.equal(pref_mask.sum(1), torch.ones_like(pref_mask.sum(1))):
+                raise RuntimeError("preference token extraction mismatch")
+            prog_hidden = hidden[prog_mask].reshape(args.micro_batch_pairs, 16, hidden_size)
+            pref_hidden = hidden[pref_mask].reshape(args.micro_batch_pairs, hidden_size)
+            progress_logits = heads.progress_head(prog_hidden[:, :8])
+            success_logits = heads.success_head(prog_hidden[:, :8]).squeeze(-1)
+            preference_logits = heads.preference_head(pref_hidden).squeeze(-1)
+            if targets["progress_mask"].any():
+                progress_frames = -(
+                    targets["progress"] * F.log_softmax(progress_logits.float(), dim=-1)
+                ).sum(-1)
+                progress_loss = progress_frames[targets["progress_mask"]].mean()
+            else:
+                raise RuntimeError("formal micro-batch has empty progress supervision")
+            success_loss = F.binary_cross_entropy_with_logits(
+                success_logits.float()[targets["success_mask"]],
+                targets["success"][targets["success_mask"]],
+                pos_weight=pos_weight,
+            )
+            preference_loss = F.binary_cross_entropy_with_logits(
+                preference_logits.float(), preference_target
+            )
+            total_loss = preference_loss + progress_loss + success_loss
+            if not torch.isfinite(total_loss):
+                raise FloatingPointError(f"non-finite loss at step {step + 1}")
+            (total_loss / args.gradient_accumulation).backward()
+            components["preference"] += float(preference_loss.detach()) / args.gradient_accumulation
+            components["progress"] += float(progress_loss.detach()) / args.gradient_accumulation
+            components["success"] += float(success_loss.detach()) / args.gradient_accumulation
+        finite, grad_norm, grad_tensors = finite_grad_audit(named_trainable)
+        if not finite:
+            raise FloatingPointError(f"non-finite gradient at step {step + 1}")
+        group_norms = {
+            "lora": group_grad_norm(named_trainable, "lora_"),
+            "token_rows": group_grad_norm(named_trainable, "trainable_tokens"),
+            "progress_head": group_grad_norm(named_trainable, "heads.progress_head"),
+            "success_head": group_grad_norm(named_trainable, "heads.success_head"),
+            "preference_head": group_grad_norm(named_trainable, "heads.preference_head"),
+        }
+        if any(value <= 0 for value in group_norms.values()):
+            raise RuntimeError(f"missing gradient group: {group_norms}")
+        torch.nn.utils.clip_grad_norm_(backbone_parameters + head_parameters, 1.0)
+        optimizer.step()
+        scheduler.step()
+        torch.cuda.synchronize()
+        elapsed = time.perf_counter() - step_started
+        step_seconds.append(elapsed)
+        record = {
+            "step": step + 1,
+            "loss": sum(components.values()),
+            "loss_components": components,
+            "gradient_norm_preclip": grad_norm,
+            "gradient_tensor_count": grad_tensors,
+            "gradient_group_norms": group_norms,
+            "step_seconds": elapsed,
+            "lora_lr": optimizer.param_groups[0]["lr"],
+            "head_lr": optimizer.param_groups[1]["lr"],
+            "sequence_tokens_min": sequence_min,
+            "sequence_tokens_max": sequence_max,
+            "peak_allocated_gib": torch.cuda.max_memory_allocated() / 2**30,
+            "peak_reserved_gib": torch.cuda.max_memory_reserved() / 2**30,
+        }
+        with progress_path.open("a", encoding="utf-8") as stream:
+            stream.write(json.dumps(record, sort_keys=True) + "\n")
+        print(json.dumps(record, sort_keys=True), flush=True)
+        completed = step + 1
+        should_evaluate = completed % args.eval_every == 0 or completed == args.optimizer_steps
+        if should_evaluate:
+            metrics = evaluate_dev(
+                model=model,
+                processor=processor,
+                heads=heads,
+                rows=dev_rows,
+                processed_root=args.processed_root,
+                token_ids=token_ids,
+                hidden_size=hidden_size,
+                pos_weight=pos_weight,
+                micro_batch_pairs=args.eval_micro_batch_pairs,
+            )
+            metrics["step"] = completed
+            eval_history.append(metrics)
+            with eval_path.open("a", encoding="utf-8") as stream:
+                stream.write(json.dumps(metrics, sort_keys=True) + "\n")
+            print(json.dumps({"id_dev": metrics}, sort_keys=True), flush=True)
+            if metrics["loss"] < best_eval_loss - args.early_stop_min_delta:
+                best_eval_loss = float(metrics["loss"])
+                best_step = completed
+                bad_eval_count = 0
+                atomic_torch_save(
+                    {
+                        "protocol_id": "phase21a_robometer_low_lora_train_v2",
+                        "selected_step": best_step,
+                        "id_dev_metrics": metrics,
+                        "adapter_state": cpu_state_dict(
+                            get_peft_model_state_dict(model.model.language_model)
+                        ),
+                        "heads_state": cpu_state_dict(heads.state_dict()),
+                    },
+                    best_model_path,
+                )
+            else:
+                bad_eval_count += 1
+
+        should_checkpoint = completed % args.checkpoint_every == 0 or completed == args.optimizer_steps
+        if should_checkpoint:
+            atomic_torch_save(
+                {
+                    "protocol_id": "phase21a_robometer_low_lora_train_v2",
+                    "completed_steps": completed,
+                    "target_steps": args.optimizer_steps,
+                    "seed": args.seed,
+                    "manifest_sha256": manifest_sha256,
+                    "adapter_state": get_peft_model_state_dict(model.model.language_model),
+                    "heads_state": heads.state_dict(),
+                    "optimizer_state": optimizer.state_dict(),
+                    "scheduler_state": scheduler.state_dict(),
+                    "numpy_generator_state": generator.bit_generator.state,
+                    "order": order,
+                    "cursor": cursor,
+                    "step_seconds": step_seconds,
+                    "eval_history": eval_history,
+                    "best_eval_loss": best_eval_loss,
+                    "best_step": best_step,
+                    "bad_eval_count": bad_eval_count,
+                    "torch_rng_state": torch.get_rng_state(),
+                    "cuda_rng_state_all": torch.cuda.get_rng_state_all(),
+                },
+                checkpoint_path,
+            )
+        if (
+            should_evaluate
+            and completed >= args.early_stop_min_steps
+            and bad_eval_count >= args.early_stop_patience_evals
+        ):
+            stop_reason = "id_dev_early_stop"
+            break
+    if not best_model_path.is_file():
+        raise RuntimeError("training completed without an ID-dev model selection checkpoint")
+    best_model = torch.load(best_model_path, map_location="cpu", weights_only=False)
+    set_peft_model_state_dict(model.model.language_model, best_model["adapter_state"])
+    heads.load_state_dict(best_model["heads_state"])
+    adapter_dir = args.output_dir / "adapter"
+    model.model.language_model.save_pretrained(adapter_dir)
+    torch.save(heads.state_dict(), args.output_dir / "reward_heads.pt")
+    summary = {
+        "status": "training_complete",
+        "protocol_id": "phase21a_robometer_low_lora_train_v2",
+        "seed": args.seed,
+        "optimizer_steps_cap": args.optimizer_steps,
+        "completed_steps": completed,
+        "selected_step": best_step,
+        "best_id_dev_loss": best_eval_loss,
+        "stop_reason": stop_reason,
+        "effective_batch_pairs": 64,
+        "mean_step_seconds": float(np.mean(step_seconds)),
+        "total_training_hours": float(np.sum(step_seconds) / 3600),
+        "final_ood_used": False,
+    }
+    (args.output_dir / "summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(summary, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

src/__init__.py

@@ -0,0 +1 @@
+"""Experiment-local implementation modules."""

src/data_contract.py

@@ -0,0 +1,467 @@
+"""Backbone-neutral trajectory contract for Route A.
+
+The module deliberately stops before model-specific normalization. Every backbone
+therefore receives the same selected RGB frames, labels and masks.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import Any, Iterable, Literal, Sequence
+
+import numpy as np
+import torch
+from PIL import Image
+
+
+TemporalStrategy = Literal["forward", "reverse", "rewind", "different_task"]
+
+
+def deterministic_frame_indices(
+    frame_count: int, target_frames: int = 8
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return official-style rint(linspace) indices and a real-frame mask."""
+
+    if frame_count <= 0 or target_frames <= 0:
+        raise ValueError("frame_count and target_frames must be positive")
+    if frame_count >= target_frames:
+        indices = np.rint(
+            np.linspace(0, frame_count - 1, target_frames)
+        ).astype(np.int64)
+        indices[0] = 0
+        indices[-1] = frame_count - 1
+        return indices, np.ones(target_frames, dtype=np.bool_)
+
+    real = np.arange(frame_count, dtype=np.int64)
+    padding = np.full(target_frames - frame_count, frame_count - 1, dtype=np.int64)
+    valid = np.concatenate(
+        [
+            np.ones(frame_count, dtype=np.bool_),
+            np.zeros(target_frames - frame_count, dtype=np.bool_),
+        ]
+    )
+    return np.concatenate([real, padding]), valid
+
+
+def temporal_permutation(length: int, strategy: TemporalStrategy) -> np.ndarray:
+    """Return a permutation shared by frames, labels, indices and masks."""
+
+    if length <= 0:
+        raise ValueError("length must be positive")
+    if strategy in ("forward", "different_task"):
+        return np.arange(length, dtype=np.int64)
+    if strategy == "reverse":
+        return np.arange(length - 1, -1, -1, dtype=np.int64)
+    if strategy == "rewind":
+        split = length // 2
+        return np.concatenate(
+            [
+                np.arange(split, dtype=np.int64),
+                np.arange(length - 1, split - 1, -1, dtype=np.int64),
+            ]
+        )
+    raise ValueError(f"unsupported temporal strategy: {strategy}")
+
+
+def letterbox_rgb(frame: np.ndarray, canvas_size: int = 256) -> np.ndarray:
+    """Deterministically resize an RGB uint8 frame onto a square black canvas."""
+
+    if (
+        frame.ndim != 3
+        or frame.shape[-1] != 3
+        or frame.dtype != np.uint8
+        or canvas_size <= 0
+    ):
+        raise ValueError("frame must be uint8 [H,W,3] and canvas_size must be positive")
+    height, width = frame.shape[:2]
+    if height <= 0 or width <= 0:
+        raise ValueError("frame dimensions must be positive")
+    scale = min(canvas_size / width, canvas_size / height)
+    resized_width = max(1, min(canvas_size, round(width * scale)))
+    resized_height = max(1, min(canvas_size, round(height * scale)))
+    resized = Image.fromarray(frame, mode="RGB").resize(
+        (resized_width, resized_height), Image.Resampling.BILINEAR
+    )
+    canvas = Image.new("RGB", (canvas_size, canvas_size), (0, 0, 0))
+    offset = (
+        (canvas_size - resized_width) // 2,
+        (canvas_size - resized_height) // 2,
+    )
+    canvas.paste(resized, offset)
+    return np.asarray(canvas, dtype=np.uint8)
+
+
+def _c51_targets(values: np.ndarray, bins: int) -> np.ndarray:
+    if bins < 2:
+        raise ValueError("progress bins must be at least 2")
+    positions = np.clip(values, 0.0, 1.0) * (bins - 1)
+    lower = np.floor(positions).astype(np.int64)
+    upper = np.ceil(positions).astype(np.int64)
+    output = np.zeros((len(values), bins), dtype=np.float32)
+    rows = np.arange(len(values))
+    output[rows, lower] += upper - positions
+    output[rows, upper] += positions - lower
+    exact = lower == upper
+    output[rows[exact], lower[exact]] = 1.0
+    return output
+
+
+@dataclass(frozen=True)
+class TrajectoryContract:
+    trajectory_id: str
+    task: str
+    data_source: str
+    quality_label: str
+    frames_uint8: np.ndarray
+    source_frame_indices: np.ndarray
+    frame_valid_mask: np.ndarray
+    progress: np.ndarray
+    progress_distribution: np.ndarray
+    progress_loss_mask: np.ndarray
+    success_labels: np.ndarray
+    success_loss_mask: np.ndarray
+    strategy: TemporalStrategy
+    metadata: dict[str, Any]
+
+    def validate(self) -> None:
+        frame_count = self.frames_uint8.shape[0]
+        if self.frames_uint8.dtype != np.uint8 or self.frames_uint8.ndim != 4:
+            raise ValueError("frames_uint8 must be uint8 [T,H,W,3]")
+        if self.frames_uint8.shape[-1] != 3:
+            raise ValueError("frames_uint8 must have three RGB channels")
+        aligned = (
+            self.source_frame_indices,
+            self.frame_valid_mask,
+            self.progress,
+            self.progress_distribution,
+            self.progress_loss_mask,
+            self.success_labels,
+            self.success_loss_mask,
+        )
+        if any(value.shape[0] != frame_count for value in aligned):
+            raise ValueError("all frame-level fields must have the same leading size")
+        if np.any(self.progress < 0) or np.any(self.progress > 1):
+            raise ValueError("progress values must be in [0,1]")
+        if np.any(self.progress_loss_mask & ~self.frame_valid_mask):
+            raise ValueError("padding may not enter progress loss")
+        if np.any(self.success_loss_mask & ~self.frame_valid_mask):
+            raise ValueError("padding may not enter success loss")
+
+
+@dataclass(frozen=True)
+class PreferenceContract:
+    trajectory_a: TrajectoryContract
+    trajectory_b: TrajectoryContract
+    preference_label: float
+    strategy: str
+
+    def swapped(self) -> PreferenceContract:
+        return replace(
+            self,
+            trajectory_a=self.trajectory_b,
+            trajectory_b=self.trajectory_a,
+            preference_label=1.0 - self.preference_label,
+        )
+
+
+def prepare_trajectory(
+    *,
+    trajectory_id: str,
+    frames: np.ndarray,
+    task: str,
+    data_source: str,
+    quality_label: str,
+    partial_success: float | None = None,
+    strategy: TemporalStrategy = "forward",
+    target_frames: int = 8,
+    canvas_size: int = 256,
+    progress_bins: int = 10,
+    success_cutoff: float = 1.0,
+    metadata: dict[str, Any] | None = None,
+) -> TrajectoryContract:
+    """Materialize one auditable trajectory from an official sampler trajectory."""
+
+    if frames.ndim != 4 or frames.shape[-1] != 3 or frames.dtype != np.uint8:
+        raise ValueError("frames must be uint8 [T,H,W,3]")
+    if not trajectory_id or not task or not data_source:
+        raise ValueError("trajectory_id, task and data_source are required")
+    if partial_success is not None and not 0.0 <= partial_success <= 1.0:
+        raise ValueError("partial_success must be in [0,1]")
+    if not 0.0 <= success_cutoff <= 1.0:
+        raise ValueError("success_cutoff must be in [0,1]")
+
+    selected_indices, frame_valid = deterministic_frame_indices(
+        len(frames), target_frames
+    )
+    permutation = temporal_permutation(target_frames, strategy)
+    selected_indices = selected_indices[permutation]
+    frame_valid = frame_valid[permutation]
+    selected_frames = np.stack(
+        [letterbox_rgb(frames[index], canvas_size) for index in selected_indices]
+    )
+
+    denominator = max(len(frames) - 1, 1)
+    progress = selected_indices.astype(np.float32) / denominator
+    if partial_success is not None:
+        progress *= partial_success
+    if strategy == "different_task":
+        progress.fill(0.0)
+
+    quality = quality_label.lower()
+    dense_progress_allowed = quality not in {"failure", "failed", "suboptimal"}
+    progress_loss_mask = frame_valid & dense_progress_allowed
+    if strategy == "different_task":
+        progress_loss_mask = frame_valid.copy()
+    success_labels = (
+        (progress >= success_cutoff)
+        & (quality == "successful")
+        & frame_valid
+    ).astype(np.float32)
+    success_loss_mask = frame_valid.copy()
+    audit_metadata = dict(metadata or {})
+    audit_metadata.update(
+        {
+            "source_frame_count": int(len(frames)),
+            "selected_frame_indices": selected_indices.tolist(),
+            "frame_valid_mask": frame_valid.tolist(),
+            "temporal_strategy": strategy,
+            "canvas_size": canvas_size,
+            "letterbox_fill_rgb": [0, 0, 0],
+        }
+    )
+    result = TrajectoryContract(
+        trajectory_id=trajectory_id,
+        task=task,
+        data_source=data_source,
+        quality_label=quality_label,
+        frames_uint8=selected_frames,
+        source_frame_indices=selected_indices,
+        frame_valid_mask=frame_valid,
+        progress=progress,
+        progress_distribution=_c51_targets(progress, progress_bins),
+        progress_loss_mask=progress_loss_mask,
+        success_labels=success_labels,
+        success_loss_mask=success_loss_mask,
+        strategy=strategy,
+        metadata=audit_metadata,
+    )
+    result.validate()
+    return result
+
+
+def adapt_official_trajectory(
+    trajectory: Any,
+    *,
+    strategy: TemporalStrategy,
+    progress_supervised: bool,
+    canvas_size: int = 256,
+    progress_bins: int = 10,
+) -> TrajectoryContract:
+    """Adapt an official Robometer sampler trajectory without changing its labels.
+
+    The sampler must expose its selected source indices and padding mask in
+    ``trajectory.metadata``. This is intentionally strict: silently re-sampling
+    here would invalidate the matched-backbone comparison.
+    """
+
+    metadata = dict(trajectory.metadata or {})
+    if "selected_frame_indices" not in metadata or "frame_valid_mask" not in metadata:
+        raise ValueError("official sampler metadata lacks frozen frame indices/mask")
+    frames = np.asarray(trajectory.frames)
+    if frames.ndim != 4 or frames.shape[-1] != 3 or frames.dtype != np.uint8:
+        raise ValueError("official sampler frames must be uint8 [T,H,W,3]")
+    selected_indices = np.asarray(metadata["selected_frame_indices"], dtype=np.int64)
+    frame_valid = np.asarray(metadata["frame_valid_mask"], dtype=np.bool_)
+    if len(selected_indices) != len(frames) or len(frame_valid) != len(frames):
+        raise ValueError("official sampler frame metadata is not aligned")
+
+    target_progress = trajectory.target_progress
+    if target_progress is None or len(target_progress) != len(frames):
+        raise ValueError("official target_progress is missing or misaligned")
+    first_target = target_progress[0]
+    if isinstance(first_target, torch.Tensor) or np.asarray(first_target).ndim > 0:
+        progress_distribution = np.stack(
+            [np.asarray(value, dtype=np.float32) for value in target_progress]
+        )
+        if progress_distribution.shape != (len(frames), progress_bins):
+            raise ValueError("official discrete progress target has unexpected shape")
+        support = np.linspace(0.0, 1.0, progress_bins, dtype=np.float32)
+        progress = progress_distribution @ support
+    else:
+        progress = np.asarray(target_progress, dtype=np.float32)
+        progress_distribution = _c51_targets(progress, progress_bins)
+
+    predict_mask = trajectory.predict_last_frame_mask
+    if predict_mask is None:
+        predict_valid = np.ones(len(frames), dtype=np.bool_)
+    else:
+        predict_valid = np.asarray(predict_mask, dtype=np.float32) > 0
+    progress_loss_mask = frame_valid & predict_valid & progress_supervised
+    success_labels = np.asarray(trajectory.success_label, dtype=np.float32)
+    if success_labels.shape != (len(frames),):
+        raise ValueError("official success labels are missing or misaligned")
+
+    metadata.update(
+        {
+            "adapter": "official_robometer_sampler_v1",
+            "temporal_strategy": strategy,
+            "canvas_size": canvas_size,
+            "letterbox_fill_rgb": [0, 0, 0],
+        }
+    )
+    result = TrajectoryContract(
+        trajectory_id=trajectory.id,
+        task=trajectory.task,
+        data_source=trajectory.data_source,
+        quality_label=trajectory.quality_label,
+        frames_uint8=np.stack(
+            [letterbox_rgb(frame, canvas_size) for frame in frames]
+        ),
+        source_frame_indices=selected_indices,
+        frame_valid_mask=frame_valid,
+        progress=progress,
+        progress_distribution=progress_distribution,
+        progress_loss_mask=progress_loss_mask,
+        success_labels=success_labels,
+        success_loss_mask=frame_valid.copy(),
+        strategy=strategy,
+        metadata=metadata,
+    )
+    result.validate()
+    return result
+
+
+def make_preference_contract(
+    chosen: TrajectoryContract,
+    rejected: TrajectoryContract,
+    *,
+    strategy: str,
+    chosen_first: bool = True,
+) -> PreferenceContract:
+    if chosen_first:
+        return PreferenceContract(chosen, rejected, 1.0, strategy)
+    return PreferenceContract(rejected, chosen, 0.0, strategy)
+
+
+class CosmosRBMCollator:
+    """Stack the frozen contract without invoking a backbone processor."""
+
+    schema_version = "cosmos_rbm_batch_v1"
+
+    @staticmethod
+    def _stack_trajectories(items: Sequence[TrajectoryContract]) -> dict[str, Any]:
+        for item in items:
+            item.validate()
+        return {
+            "frames_uint8": torch.from_numpy(
+                np.stack([item.frames_uint8 for item in items])
+            ),
+            "source_frame_indices": torch.from_numpy(
+                np.stack([item.source_frame_indices for item in items])
+            ),
+            "frame_valid_mask": torch.from_numpy(
+                np.stack([item.frame_valid_mask for item in items])
+            ),
+            "progress": torch.from_numpy(np.stack([item.progress for item in items])),
+            "progress_distribution": torch.from_numpy(
+                np.stack([item.progress_distribution for item in items])
+            ),
+            "progress_loss_mask": torch.from_numpy(
+                np.stack([item.progress_loss_mask for item in items])
+            ),
+            "success_labels": torch.from_numpy(
+                np.stack([item.success_labels for item in items])
+            ),
+            "success_loss_mask": torch.from_numpy(
+                np.stack([item.success_loss_mask for item in items])
+            ),
+            "trajectory_ids": [item.trajectory_id for item in items],
+            "tasks": [item.task for item in items],
+            "data_sources": [item.data_source for item in items],
+            "quality_labels": [item.quality_label for item in items],
+            "strategies": [item.strategy for item in items],
+            "metadata": [item.metadata for item in items],
+        }
+
+    def __call__(
+        self, samples: Sequence[TrajectoryContract | PreferenceContract]
+    ) -> dict[str, Any]:
+        trajectories = [item for item in samples if isinstance(item, TrajectoryContract)]
+        preferences = [item for item in samples if isinstance(item, PreferenceContract)]
+        output: dict[str, Any] = {
+            "schema_version": self.schema_version,
+            "num_trajectories": len(trajectories),
+            "num_preferences": len(preferences),
+        }
+        if trajectories:
+            output["trajectory_inputs"] = self._stack_trajectories(trajectories)
+        if preferences:
+            output["preference_inputs"] = {
+                "trajectory_a": self._stack_trajectories(
+                    [item.trajectory_a for item in preferences]
+                ),
+                "trajectory_b": self._stack_trajectories(
+                    [item.trajectory_b for item in preferences]
+                ),
+                "preference_labels": torch.tensor(
+                    [item.preference_label for item in preferences], dtype=torch.float32
+                ),
+                "strategies": [item.strategy for item in preferences],
+            }
+        return output
+
+
+def validate_span_bounds(
+    bounds: Sequence[tuple[int, int]], frame_count: int, sequence_length: int
+) -> None:
+    """Validate the one-frame/one-nonoverlapping-token-span contract."""
+
+    if len(bounds) != frame_count:
+        raise ValueError("visual span count must match frame count")
+    previous_stop = -1
+    for start, stop in bounds:
+        if start < 0 or stop <= start or stop > sequence_length:
+            raise ValueError("visual token span is empty or out of bounds")
+        if start < previous_stop:
+            raise ValueError("visual token spans overlap")
+        previous_stop = stop
+
+
+def worker_invariant_sample_ids(
+    ids: Iterable[str], *, seed: int, worker_count: int
+) -> list[str]:
+    """Simulate round-robin worker sharding while preserving global sample order."""
+
+    if worker_count <= 0:
+        raise ValueError("worker_count must be positive")
+    materialized = list(ids)
+    unique = list(dict.fromkeys(materialized))
+    if len(unique) != len(materialized):
+        raise ValueError("sample ids must be unique")
+    ranked = sorted(
+        unique,
+        key=lambda value: hashlib.sha256(f"{seed}:{value}".encode()).digest(),
+    )
+    shards = [list(enumerate(ranked))[worker::worker_count] for worker in range(worker_count)]
+    return [value for _, value in sorted(item for shard in shards for item in shard)]
+
+
+def audit_group_overlap(train_ids: Iterable[str], eval_ids: Iterable[str]) -> set[str]:
+    return set(train_ids) & set(eval_ids)
+
+
+def dump_batch_audit(batch: dict[str, Any], output: Path) -> None:
+    """Write metadata and tensor shapes only; never dump trajectory pixels."""
+
+    def describe(value: Any) -> Any:
+        if isinstance(value, torch.Tensor):
+            return {"shape": list(value.shape), "dtype": str(value.dtype)}
+        if isinstance(value, dict):
+            return {key: describe(item) for key, item in value.items()}
+        return value
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(describe(batch), indent=2) + "\n", encoding="utf-8")

src/reward_heads.py

@@ -0,0 +1,173 @@
+"""Shared frame pooling, temporal pooling and reward heads for B1/C0/C1."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+
+
+@dataclass(frozen=True)
+class SpanPoolResult:
+    frame_features: torch.Tensor
+    frame_mask: torch.Tensor
+    span_bounds: tuple[tuple[tuple[int, int], ...], ...]
+
+
+def pool_image_token_spans(
+    hidden_states: torch.Tensor,
+    input_ids: torch.Tensor,
+    image_token_id: int,
+    image_grid_thw: torch.Tensor,
+    frames_per_sample: list[int],
+    spatial_merge_size: int,
+) -> SpanPoolResult:
+    """Mean-pool each image-token span and return padded per-frame features."""
+
+    if hidden_states.ndim != 3 or input_ids.ndim != 2:
+        raise ValueError("hidden_states/input_ids must have shapes [B,S,D] and [B,S]")
+    if hidden_states.shape[:2] != input_ids.shape:
+        raise ValueError("hidden_states and input_ids batch/sequence dimensions differ")
+    if len(frames_per_sample) != hidden_states.shape[0] or any(
+        count <= 0 for count in frames_per_sample
+    ):
+        raise ValueError(
+            "frames_per_sample must contain one positive count per batch item"
+        )
+    if sum(frames_per_sample) != image_grid_thw.shape[0]:
+        raise ValueError("frames_per_sample does not match image_grid_thw rows")
+    if spatial_merge_size <= 0:
+        raise ValueError("spatial_merge_size must be positive")
+
+    max_frames = max(frames_per_sample)
+    features = hidden_states.new_zeros(
+        (hidden_states.shape[0], max_frames, hidden_states.shape[-1])
+    )
+    frame_mask = torch.zeros(
+        (hidden_states.shape[0], max_frames),
+        dtype=torch.bool,
+        device=hidden_states.device,
+    )
+    all_bounds: list[tuple[tuple[int, int], ...]] = []
+    grid_offset = 0
+    merge_area = spatial_merge_size**2
+
+    for batch_index, frame_count in enumerate(frames_per_sample):
+        positions = torch.nonzero(
+            input_ids[batch_index] == image_token_id, as_tuple=False
+        ).flatten()
+        token_offset = 0
+        bounds: list[tuple[int, int]] = []
+        for frame_index in range(frame_count):
+            grid_t, grid_h, grid_w = (
+                int(value) for value in image_grid_thw[grid_offset + frame_index]
+            )
+            raw_tokens = grid_t * grid_h * grid_w
+            if raw_tokens % merge_area:
+                raise ValueError(
+                    "image token grid is not divisible by spatial merge area"
+                )
+            span_length = raw_tokens // merge_area
+            frame_positions = positions[token_offset : token_offset + span_length]
+            if frame_positions.numel() != span_length:
+                raise ValueError("image token span is empty or truncated")
+            if frame_positions.numel() > 1 and not torch.all(
+                frame_positions[1:] == frame_positions[:-1] + 1
+            ):
+                raise ValueError("image token span is not contiguous")
+            start = int(frame_positions[0])
+            stop = int(frame_positions[-1]) + 1
+            features[batch_index, frame_index] = hidden_states[
+                batch_index, frame_positions
+            ].mean(dim=0)
+            frame_mask[batch_index, frame_index] = True
+            bounds.append((start, stop))
+            token_offset += span_length
+        if token_offset != positions.numel():
+            raise ValueError("unassigned image tokens remain after span pooling")
+        all_bounds.append(tuple(bounds))
+        grid_offset += frame_count
+
+    return SpanPoolResult(features, frame_mask, tuple(all_bounds))
+
+
+class MaskedQueryPool(nn.Module):
+    """Single-query attention pooling over valid ordered-frame features."""
+
+    def __init__(self, hidden_size: int) -> None:
+        super().__init__()
+        self.query = nn.Parameter(torch.empty(hidden_size))
+        nn.init.normal_(self.query, mean=0.0, std=hidden_size**-0.5)
+
+    def forward(
+        self, frame_features: torch.Tensor, frame_mask: torch.Tensor
+    ) -> torch.Tensor:
+        if frame_features.ndim != 3 or frame_mask.shape != frame_features.shape[:2]:
+            raise ValueError("expected frame_features [B,T,D] and frame_mask [B,T]")
+        if not torch.all(frame_mask.any(dim=1)):
+            raise ValueError("every trajectory must contain at least one valid frame")
+        scores = torch.einsum("btd,d->bt", frame_features, self.query) / math.sqrt(
+            frame_features.shape[-1]
+        )
+        scores = scores.masked_fill(~frame_mask, torch.finfo(scores.dtype).min)
+        weights = torch.softmax(scores.float(), dim=1).to(frame_features.dtype)
+        return torch.einsum("bt,btd->bd", weights, frame_features)
+
+
+class MLPHead(nn.Module):
+    def __init__(
+        self, hidden_size: int, output_size: int, dropout: float = 0.1
+    ) -> None:
+        super().__init__()
+        bottleneck = hidden_size // 2
+        self.net = nn.Sequential(
+            nn.Linear(hidden_size, bottleneck),
+            nn.LayerNorm(bottleneck),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(bottleneck, output_size),
+        )
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.net(inputs)
+
+
+class SharedRewardHeads(nn.Module):
+    """The identical topology used for frozen probes and matched-LoRA runs."""
+
+    def __init__(
+        self, hidden_size: int, progress_bins: int = 10, dropout: float = 0.1
+    ) -> None:
+        super().__init__()
+        self.temporal_pool = MaskedQueryPool(hidden_size)
+        self.progress_head = MLPHead(hidden_size, progress_bins, dropout)
+        self.success_head = MLPHead(hidden_size, 1, dropout)
+        self.preference_head = MLPHead(hidden_size, 1, dropout)
+
+    def forward(
+        self, frame_features: torch.Tensor, frame_mask: torch.Tensor
+    ) -> dict[str, torch.Tensor]:
+        trajectory = self.temporal_pool(frame_features, frame_mask)
+        return {
+            "progress_logits": self.progress_head(frame_features),
+            "success_logits": self.success_head(frame_features).squeeze(-1),
+            "trajectory_features": trajectory,
+            "trajectory_scores": self.preference_head(trajectory).squeeze(-1),
+        }
+
+    def preference_logit(
+        self,
+        frame_features_a: torch.Tensor,
+        frame_mask_a: torch.Tensor,
+        frame_features_b: torch.Tensor,
+        frame_mask_b: torch.Tensor,
+    ) -> torch.Tensor:
+        score_a = self.preference_head(
+            self.temporal_pool(frame_features_a, frame_mask_a)
+        ).squeeze(-1)
+        score_b = self.preference_head(
+            self.temporal_pool(frame_features_b, frame_mask_b)
+        ).squeeze(-1)
+        return score_a - score_b

tests/conftest.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+EXPERIMENT_ROOT = Path(__file__).resolve().parents[1]
+if str(EXPERIMENT_ROOT) not in sys.path:
+    sys.path.insert(0, str(EXPERIMENT_ROOT))

tests/test_data_contract.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+from types import SimpleNamespace
+
+from src.data_contract import (
+    CosmosRBMCollator,
+    adapt_official_trajectory,
+    audit_group_overlap,
+    deterministic_frame_indices,
+    make_preference_contract,
+    prepare_trajectory,
+    validate_span_bounds,
+    worker_invariant_sample_ids,
+)
+from src.reward_heads import SharedRewardHeads
+
+
+def synthetic_frames(count: int, height: int = 12, width: int = 20) -> np.ndarray:
+    frames = np.empty((count, height, width, 3), dtype=np.uint8)
+    for index in range(count):
+        frames[index].fill(index)
+    return frames
+
+
+def prepared(
+    *,
+    strategy: str = "forward",
+    quality: str = "successful",
+    frame_count: int = 13,
+    trajectory_id: str = "trajectory-a",
+):
+    return prepare_trajectory(
+        trajectory_id=trajectory_id,
+        frames=synthetic_frames(frame_count),
+        task="insert cable",
+        data_source="unit_test",
+        quality_label=quality,
+        strategy=strategy,
+        canvas_size=16,
+    )
+
+
+def test_forward_progress_is_nondecreasing_and_sampling_is_exact() -> None:
+    item = prepared()
+    expected, _ = deterministic_frame_indices(13, 8)
+    assert np.array_equal(item.source_frame_indices, expected)
+    assert np.all(np.diff(item.progress) >= 0)
+    assert item.frames_uint8.shape == (8, 16, 16, 3)
+
+
+def test_reverse_keeps_all_frame_fields_synchronized() -> None:
+    forward = prepared()
+    reverse = prepared(strategy="reverse")
+    assert np.array_equal(reverse.source_frame_indices, forward.source_frame_indices[::-1])
+    assert np.array_equal(reverse.progress, forward.progress[::-1])
+    assert np.array_equal(reverse.frame_valid_mask, forward.frame_valid_mask[::-1])
+    assert np.array_equal(reverse.success_labels, forward.success_labels[::-1])
+
+
+def test_rewind_has_a_real_progress_drop() -> None:
+    rewind = prepared(strategy="rewind")
+    assert np.any(np.diff(rewind.progress) < 0)
+
+
+def test_different_task_is_zero_with_supervision() -> None:
+    item = prepared(strategy="different_task", quality="failure")
+    assert np.all(item.progress == 0)
+    assert np.array_equal(item.progress_loss_mask, item.frame_valid_mask)
+
+
+def test_preference_swap_flips_label_and_bradley_terry_logit() -> None:
+    chosen = prepared(trajectory_id="chosen")
+    rejected = prepared(strategy="rewind", trajectory_id="rejected")
+    pair = make_preference_contract(chosen, rejected, strategy="rewind")
+    swapped = pair.swapped()
+    assert swapped.preference_label == 0.0
+    assert swapped.trajectory_a.trajectory_id == "rejected"
+
+    torch.manual_seed(7)
+    heads = SharedRewardHeads(hidden_size=8, dropout=0.0)
+    features_a = torch.randn(1, 8, 8)
+    features_b = torch.randn(1, 8, 8)
+    mask = torch.ones(1, 8, dtype=torch.bool)
+    ab = heads.preference_logit(features_a, mask, features_b, mask)
+    ba = heads.preference_logit(features_b, mask, features_a, mask)
+    assert torch.allclose(ab, -ba)
+
+
+def test_padding_never_enters_loss_or_pooling() -> None:
+    item = prepared(frame_count=3)
+    batch = CosmosRBMCollator()([item])["trajectory_inputs"]
+    assert batch["frame_valid_mask"].tolist() == [
+        [True, True, True, False, False, False, False, False]
+    ]
+    assert not batch["progress_loss_mask"][0, 3:].any()
+    assert not batch["success_loss_mask"][0, 3:].any()
+
+    pool_features = torch.randn(1, 8, 4)
+    heads = SharedRewardHeads(hidden_size=4, dropout=0.0)
+    score_a = heads(pool_features, batch["frame_valid_mask"])["trajectory_scores"]
+    pool_features[:, 3:] = 1000
+    score_b = heads(pool_features, batch["frame_valid_mask"])["trajectory_scores"]
+    assert torch.allclose(score_a, score_b)
+
+
+def test_failure_does_not_receive_dense_progress() -> None:
+    failure = prepared(quality="failure")
+    assert not failure.progress_loss_mask.any()
+    assert not failure.success_labels.any()
+
+
+def test_official_sampler_adapter_preserves_labels_and_indices() -> None:
+    official_progress = np.linspace(0.0, 1.0, 8, dtype=np.float32)
+    official_success = [0.0] * 7 + [1.0]
+    trajectory = SimpleNamespace(
+        id="official-a",
+        task="insert cable",
+        data_source="official_unit_test",
+        quality_label="successful",
+        frames=synthetic_frames(8),
+        target_progress=official_progress.tolist(),
+        success_label=official_success,
+        predict_last_frame_mask=[1.0] * 8,
+        metadata={
+            "selected_frame_indices": [0, 4, 9, 13, 18, 22, 27, 31],
+            "frame_valid_mask": [True] * 8,
+        },
+    )
+    adapted = adapt_official_trajectory(
+        trajectory,
+        strategy="forward",
+        progress_supervised=True,
+        canvas_size=16,
+    )
+    assert np.allclose(adapted.progress, official_progress)
+    assert adapted.success_labels.tolist() == official_success
+    assert adapted.source_frame_indices.tolist() == trajectory.metadata[
+        "selected_frame_indices"
+    ]
+    assert adapted.metadata["adapter"] == "official_robometer_sampler_v1"
+
+
+def test_all_backbones_consume_the_same_frozen_indices() -> None:
+    frozen, _ = deterministic_frame_indices(32, 8)
+    for _backbone in ("qwen3-vl", "cosmos3-edge", "frozen-cosmos"):
+        item = prepared(frame_count=32)
+        assert np.array_equal(item.source_frame_indices, frozen)
+
+
+def test_visual_span_contract() -> None:
+    validate_span_bounds([(1, 4), (8, 11), (12, 15)], 3, 16)
+    with pytest.raises(ValueError, match="overlap"):
+        validate_span_bounds([(1, 5), (4, 8)], 2, 10)
+    with pytest.raises(ValueError, match="count"):
+        validate_span_bounds([(1, 5)], 2, 10)
+
+
+def test_worker_count_does_not_change_seeded_sampling_list() -> None:
+    ids = [f"trajectory-{index}" for index in range(100)]
+    expected = worker_invariant_sample_ids(ids, seed=17, worker_count=1)
+    assert worker_invariant_sample_ids(ids, seed=17, worker_count=2) == expected
+    assert worker_invariant_sample_ids(ids, seed=17, worker_count=8) == expected
+
+
+def test_group_overlap_gate() -> None:
+    assert audit_group_overlap(["a", "b", "c"], ["d", "e"]) == set()
+    assert audit_group_overlap(["a", "b"], ["b", "c"]) == {"b"}
+
+
+def test_one_hundred_trajectories_cpu_collate_and_backward() -> None:
+    item = prepared()
+    batch = CosmosRBMCollator()([item] * 100)["trajectory_inputs"]
+    assert batch["frames_uint8"].shape == (100, 8, 16, 16, 3)
+    features = torch.randn(8, 8, 16, requires_grad=True)
+    heads = SharedRewardHeads(hidden_size=16, dropout=0.0)
+    output = heads(features, batch["frame_valid_mask"][:8])
+    loss = output["progress_logits"].float().mean() + output[
+        "success_logits"
+    ].float().mean()
+    loss.backward()
+    assert features.grad is not None and torch.isfinite(features.grad).all()