Add files using upload-large-folder tool

artifacts/checkpoints.yaml

@@ -0,0 +1,411 @@
+schema_version: 1
+resources:
+  flm_lm1b_hf:
+    id: flm_lm1b_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: continuous_flm
+    destination: official/flm/lm1b
+    license: apache-2.0
+    terms_url: https://huggingface.co/david3684/FLM-B-LM1B
+    digest: {policy: capture_after_download}
+    required_files: [config.json, model.safetensors]
+    source:
+      repo_id: david3684/FLM-B-LM1B
+      revision: cd0ca433d11d9392494de8122f3b63cc996fd4ce
+      allow_patterns: [README.md, config.json, model.safetensors]
+  fmlm_lm1b_hf:
+    id: fmlm_lm1b_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: continuous_flm
+    destination: official/fmlm/lm1b
+    license: apache-2.0
+    terms_url: https://huggingface.co/david3684/FMLM-B-LM1B
+    digest: {policy: capture_after_download}
+    required_files: [config.json, model.safetensors]
+    source:
+      repo_id: david3684/FMLM-B-LM1B
+      revision: 356592ce2d9af4adbf9d7b55e8e00bbfb37eb4c8
+      allow_patterns: [README.md, config.json, model.safetensors]
+  flm_owt_hf:
+    id: flm_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: continuous_flm
+    destination: official/flm/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/david3684/FLM-B-OWT
+    digest: {policy: capture_after_download}
+    required_files: [config.json, model.safetensors]
+    source:
+      repo_id: david3684/FLM-B-OWT
+      revision: 624471b934fdd0421757d62290f7e639f32566d3
+      allow_patterns: [README.md, config.json, model.safetensors]
+  fmlm_owt_hf:
+    id: fmlm_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: continuous_flm
+    destination: official/fmlm/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/david3684/FMLM-B-OWT
+    digest: {policy: capture_after_download}
+    required_files: [config.json, model.safetensors]
+    source:
+      repo_id: david3684/FMLM-B-OWT
+      revision: 483ea1b38bba56632cd40dc5a3c70a2340bb4946
+      allow_patterns: [README.md, config.json, model.safetensors]
+  langflow_owt_hf:
+    id: langflow_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: continuous_langflow
+    destination: official/langflow/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/Continuous-Rivals-Discrete/langflow-owt
+    digest: {policy: capture_after_download}
+    required_files: [config.json, config.py, model.py, model.safetensors]
+    source:
+      repo_id: Continuous-Rivals-Discrete/langflow-owt
+      revision: a08f933dd337d52762fec5ef7d60c131896cc341
+      allow_patterns: [README.md, __init__.py, config.json, config.py, model.py, model.safetensors]
+  langflow_lm1b_hf:
+    id: langflow_lm1b_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: continuous_langflow
+    destination: official/langflow/lm1b
+    license: apache-2.0
+    terms_url: https://huggingface.co/Continuous-Rivals-Discrete/langflow-lm1b
+    digest: {policy: capture_after_download}
+    required_files: [config.json, config.py, model.py, model.safetensors]
+    source:
+      repo_id: Continuous-Rivals-Discrete/langflow-lm1b
+      revision: d5d395d9bdf01f697ba8830110e3e78c63d77cb5
+      allow_patterns: [README.md, __init__.py, config.json, config.py, model.py, model.safetensors]
+  duo_owt_hf:
+    id: duo_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: uniform_duo
+    destination: official/duo/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/s-sahoo/duo
+    digest: {policy: capture_after_download}
+    required_files: [config.json, config.py, model.py, model.safetensors]
+    source:
+      repo_id: s-sahoo/duo
+      revision: ef8ad7a25a4bf9624306230913dd7ae5cb2a00bd
+      allow_patterns: [README.md, config.json, config.py, model.py, model.safetensors]
+  duo_dcd_owt_hf:
+    id: duo_dcd_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: uniform_duo
+    destination: official/duo_dcd/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/s-sahoo/duo-distilled
+    digest: {policy: capture_after_download}
+    required_files: [config.json, config.py, model.py, model.safetensors]
+    source:
+      repo_id: s-sahoo/duo-distilled
+      revision: 08ee71faabfc0e2eaaa6cb1833ed3a486931ef2b
+      allow_patterns: [README.md, config.json, config.py, model.py, model.safetensors]
+  mdlm_owt_hf:
+    id: mdlm_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: masked_mdlm
+    destination: official/mdlm/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/kuleshov-group/mdlm-owt
+    digest: {policy: capture_after_download}
+    required_files: [config.json, configuration_mdlm.py, modeling_mdlm.py, model.safetensors]
+    source:
+      repo_id: kuleshov-group/mdlm-owt
+      revision: d0958fa851335ece6c15260ce0025f030673c0fb
+      allow_patterns: [README.md, config.json, configuration_mdlm.py, modeling_mdlm.py, model.safetensors]
+  sdtt_owt_hf:
+    id: sdtt_owt_hf
+    backend: huggingface
+    provenance: official
+    teacher_family: masked_mdlm
+    destination: official/mdlm_sdtt/owt
+    license: apache-2.0
+    terms_url: https://huggingface.co/jdeschena/sdtt/tree/baselines_kld_step_70000
+    digest: {policy: capture_after_download}
+    required_files: [config.json, model.safetensors]
+    source:
+      repo_id: jdeschena/sdtt
+      revision: c84bdf45ce3a80f5a70bb09548093f1c8f2ac7a7
+      allow_patterns: [config.json, model.safetensors]
+    note: Final round-7 KLD baseline student from the masked MDLM teacher.
+  flm_lm1b_reproductions:
+    id: flm_lm1b_reproductions
+    backend: gdrive
+    provenance: reference_reproduction
+    teacher_family: mixed_baselines
+    destination: reference_reproduction/flm_baselines/lm1b
+    license: upstream-not-specified
+    terms_url: https://github.com/david3684/flm/blob/a1918d5164e5038e37d0b7a4fb2010ce75b863b3/README.md
+    digest: {policy: capture_after_download}
+    required_files: [lm1b_CANDI.ckpt, lm1b_Duo.ckpt, lm1b_MDLM_.ckpt]
+    source:
+      folder_id: 1TJO3aFWqI7ukbmjciZ6krAUFlAak1itl
+      expected_files:
+        lm1b_CANDI.ckpt: 19TbJu1VHWX5EHqE8Si4xWqBhJlTqaGjf
+        lm1b_Duo.ckpt: 1yHtaYrLX34rS5tu9V1SKF5NvwTVxPWoF
+        lm1b_MDLM_.ckpt: 1jp6Jka8tQJJ9zljihdLErokFp9TDvlsl
+    note: Supplemental reproduction folder; cells remain recipe-backed until server lock inspection proves exact filenames and teacher families.
+  duo_raw_owt_drive:
+    id: duo_raw_owt_drive
+    backend: gdrive
+    provenance: official
+    teacher_family: uniform_duo
+    destination: official/duo/raw_owt
+    license: apache-2.0-code-checkpoint-terms-upstream
+    terms_url: https://github.com/s-sahoo/duo/blob/7c9b498f5b717de064d6fad7e2509c866e6cb620/README.md
+    digest: {policy: capture_after_download}
+    required_files: [duo-distilled.ckpt, duo.ckpt]
+    source:
+      folder_id: 1JpqFM8XRvifwIkjWPfMyuDvu41r1yk0t
+      expected_files:
+        duo-distilled.ckpt: 1WaF4ITJ24rl6JhIYKfrA4FWvXaAPZjJL
+        duo.ckpt: 1SbslPVBrSWrN3V3TlngjcLapROa74o0_
+    note: Official finetunable raw OWT checkpoint folder; HF snapshots remain canonical for evaluation.
+  rdlm_lm1b_drive:
+    id: rdlm_lm1b_drive
+    backend: gdrive
+    provenance: official
+    teacher_family: continuous_rdlm
+    destination: official/rdlm/lm1b
+    license: upstream-not-specified
+    terms_url: https://github.com/harryjo97/RDLM/blob/67443aa6a2d0fa981eb7c6105f9cbc563e59c5c1/README.md
+    digest: {policy: capture_after_download}
+    required_files:
+      - LM1B/checkpoint.pth
+      - LM1B/config.yaml
+      - LM1B/sde.pkl
+      - Text8/checkpoint.pth
+      - Text8/config.yaml
+      - Text8/sde.pkl
+    source:
+      folder_id: 1aDTZtPIxAxQrkaRSahjuWbkxX1OYq9CC
+      expected_files:
+        LM1B/checkpoint.pth: 1zAqP-DtZigoiChpNfgJgJobKIZ9VOaro
+        LM1B/config.yaml: 1-rXPglhh3BqDQ0XlQqQ0wN8Gu2iNg5KU
+        LM1B/sde.pkl: 1I2yLxRSOk4jlBryFhwOfJ6L3UBmljwl_
+        Text8/checkpoint.pth: 17x9jd44hfUuhByh9XsZEeClwSnsCNQIY
+        Text8/config.yaml: 158JPIYFGm5cBRlQ2ZmY__9t4UYl9-CQl
+        Text8/sde.pkl: 1M3mzJFCOnXsQF9MKfrUGcn8sAbKtaLBh
+    note: Folder also contains Text8; server lock records the observed LM1B checkpoint, config, and SDE files.
+  di4c_mdlm_owt_zenodo:
+    id: di4c_mdlm_owt_zenodo
+    backend: zenodo
+    provenance: official
+    teacher_family: masked_mdlm
+    destination: official/mdlm_di4c/owt
+    license: zenodo-record-terms
+    terms_url: https://zenodo.org/records/15124163
+    digest: {policy: capture_after_download}
+    required_files: [sdtt7-di4c2.ckpt]
+    source:
+      record_id: 15124163
+      files: [sdtt7-di4c2.ckpt]
+      published_checksums:
+        sdtt7-di4c2.ckpt: md5:b55b961b1f0d7f2ed55539452875ec15
+    note: Masked SDTT/MDLM teacher release only; never valid for Duo/uniform Di4C cells.
+recipes:
+  flm_lm1b_official_ckpt:
+    model: flm
+    dataset: lm1b
+    provenance: official
+    teacher_family: continuous_flm
+    source: flm
+    source_commit: a1918d5164e5038e37d0b7a4fb2010ce75b863b3
+    command: >-
+      gdown --folder https://drive.google.com/drive/folders/1fNAx4LP2RwPBdqDQFQ_gRrYZI9u3Vq15
+      -O downloads/flm_official_ckpt && mkdir -p checkpoints/official/flm_ckpt/lm1b
+      && cp downloads/flm_official_ckpt/lm1b_flm.ckpt
+      checkpoints/official/flm_ckpt/lm1b/lm1b_flm.ckpt
+    output: checkpoints/official/flm_ckpt/lm1b
+    sampling_checkpoint: lm1b_flm.ckpt
+    note: Official FLM Lightning checkpoint staged from the author's public Drive release.
+  flm_owt_official_ckpt:
+    model: flm
+    dataset: owt
+    provenance: official
+    teacher_family: continuous_flm
+    source: flm
+    source_commit: a1918d5164e5038e37d0b7a4fb2010ce75b863b3
+    command: >-
+      gdown --folder https://drive.google.com/drive/folders/1fNAx4LP2RwPBdqDQFQ_gRrYZI9u3Vq15
+      -O downloads/flm_official_ckpt && mkdir -p checkpoints/official/flm_ckpt/owt
+      && cp downloads/flm_official_ckpt/owt_flm.ckpt
+      checkpoints/official/flm_ckpt/owt/owt_flm.ckpt
+    output: checkpoints/official/flm_ckpt/owt
+    sampling_checkpoint: owt_flm.ckpt
+    note: Official FLM Lightning checkpoint staged from the author's public Drive release.
+  fmlm_lm1b_official_ckpt:
+    model: fmlm
+    dataset: lm1b
+    provenance: official
+    teacher_family: continuous_flm
+    source: flm
+    source_commit: a1918d5164e5038e37d0b7a4fb2010ce75b863b3
+    command: >-
+      gdown --folder https://drive.google.com/drive/folders/1fNAx4LP2RwPBdqDQFQ_gRrYZI9u3Vq15
+      -O downloads/flm_official_ckpt && mkdir -p checkpoints/official/fmlm_ckpt/lm1b
+      && cp downloads/flm_official_ckpt/lm1b_fmlm.ckpt
+      checkpoints/official/fmlm_ckpt/lm1b/lm1b_fmlm.ckpt
+    output: checkpoints/official/fmlm_ckpt/lm1b
+    sampling_checkpoint: lm1b_fmlm.ckpt
+    note: Official FMLM Lightning checkpoint staged from the author's public Drive release.
+  fmlm_owt_official_ckpt:
+    model: fmlm
+    dataset: owt
+    provenance: official
+    teacher_family: continuous_flm
+    source: flm
+    source_commit: a1918d5164e5038e37d0b7a4fb2010ce75b863b3
+    command: >-
+      gdown --folder https://drive.google.com/drive/folders/1fNAx4LP2RwPBdqDQFQ_gRrYZI9u3Vq15
+      -O downloads/flm_official_ckpt && mkdir -p checkpoints/official/fmlm_ckpt/owt
+      && cp downloads/flm_official_ckpt/owt_fmlm.ckpt
+      checkpoints/official/fmlm_ckpt/owt/owt_fmlm.ckpt
+    output: checkpoints/official/fmlm_ckpt/owt
+    sampling_checkpoint: owt_fmlm.ckpt
+    note: Official FMLM Lightning checkpoint staged from the author's public Drive release.
+  candi_owt:
+    model: candi
+    dataset: owt
+    provenance: reference_reproduction
+    teacher_family: hybrid_candi
+    source: candi
+    source_commit: cd57ae9eec98d6ac71cd52bdc50eeec8dfd70f91
+    command: >-
+      bash scripts/train/candi.sh --source upstreams/candi --dataset owt
+      --output checkpoints/reference_reproduction/candi/owt
+    output: checkpoints/reference_reproduction/candi/owt
+    sampling_checkpoint: model.ckpt
+    sampling_config: config.yaml
+    note: Explicit prerequisite for the project-owned Task 12 wrapper; the upstream site-specific Slurm job is not invoked directly.
+  duo_dcd_lm1b:
+    model: duo_dcd
+    dataset: lm1b
+    provenance: reference_reproduction
+    teacher_family: uniform_duo
+    source: duo
+    source_commit: 7c9b498f5b717de064d6fad7e2509c866e6cb620
+    command: >-
+      bash scripts/distill/duo_dcd.sh --source upstreams/duo --dataset lm1b
+      --teacher checkpoints/reference_reproduction/flm_baselines/lm1b/lm1b_Duo.ckpt
+      --output checkpoints/reference_reproduction/duo_dcd/lm1b
+      --rounds 8 --steps-per-round 10000 --global-batch-size 128
+      --learning-rate 6e-5
+    output: checkpoints/reference_reproduction/duo_dcd/lm1b
+    sampling_checkpoint: model.ckpt
+    sampling_config: config.yaml
+    prerequisites: [flm_lm1b_reproductions]
+    note: Explicit prerequisite for the project-owned Task 12 wrapper; do not substitute the OWT distilled snapshot or alter the reference schedule.
+  duo_di4c_lm1b:
+    model: duo_di4c
+    dataset: lm1b
+    provenance: reference_reproduction
+    teacher_family: uniform_duo
+    source: di4c
+    source_commit: ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3
+    teacher_adapter: uniform_to_absorbing
+    command: >-
+      bash scripts/distill/di4c.sh --model duo_di4c --dataset lm1b
+      --teacher-family uniform_duo
+      --teacher-checkpoint checkpoints/reference_reproduction/flm_baselines/lm1b/lm1b_Duo.ckpt
+      --output checkpoints/reference_reproduction/duo_di4c/lm1b
+      --student-init teacher
+      --upstream-override is_di4c=true
+    output: checkpoints/reference_reproduction/duo_di4c/lm1b
+    sampling_checkpoint: student_checkpoints/20000.ckpt
+    sampling_config: config.yaml
+    prerequisites: [flm_lm1b_reproductions]
+    note: Task 12's repository wrapper must adapt the uniform Duo vocabulary/head to the absorbing Di4C shape; Zenodo SDTT files are forbidden substitutes.
+  duo_di4c_owt:
+    model: duo_di4c
+    dataset: owt
+    provenance: reference_reproduction
+    teacher_family: uniform_duo
+    source: di4c
+    source_commit: ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3
+    teacher_adapter: uniform_to_absorbing
+    command: >-
+      bash scripts/distill/di4c.sh --model duo_di4c --dataset owt
+      --teacher-family uniform_duo
+      --teacher-checkpoint checkpoints/official/duo/raw_owt/duo.ckpt
+      --output checkpoints/reference_reproduction/duo_di4c/owt
+      --student-init hf_small
+      --upstream-override is_di4c=true
+    output: checkpoints/reference_reproduction/duo_di4c/owt
+    sampling_checkpoint: student_checkpoints/50000.ckpt
+    sampling_config: config.yaml
+    prerequisites: [duo_raw_owt_drive]
+    note: Task 12's repository wrapper must adapt the uniform Duo vocabulary/head to the absorbing Di4C shape; never relabel the masked-teacher Zenodo checkpoint.
+  mdlm_sdtt_lm1b:
+    model: mdlm_sdtt
+    dataset: lm1b
+    provenance: reference_reproduction
+    teacher_family: masked_mdlm
+    source: sdtt
+    source_commit: 1150985e90b8f2d5749e4469d5154eff9ec922c4
+    teacher_adapter: masked_to_absorbing
+    command: >-
+      bash scripts/distill/mdlm_sdtt.sh --model mdlm_sdtt --dataset lm1b
+      --teacher-family masked_mdlm
+      --teacher-checkpoint checkpoints/reference_reproduction/flm_baselines/lm1b/lm1b_MDLM_.ckpt
+      --output checkpoints/reference_reproduction/mdlm_sdtt/lm1b
+    output: checkpoints/reference_reproduction/mdlm_sdtt/lm1b
+    sampling_checkpoint: student_checkpoints/70000.ckpt
+    sampling_config: config.yaml
+    prerequisites: [flm_lm1b_reproductions]
+    note: Task 12's repository wrapper must adapt the BERT masked teacher to the absorbing SDTT shape; the upstream loader is not shape-compatible directly.
+  mdlm_di4c_lm1b:
+    model: mdlm_di4c
+    dataset: lm1b
+    provenance: reference_reproduction
+    teacher_family: masked_mdlm
+    source: di4c
+    source_commit: ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3
+    teacher_adapter: masked_to_absorbing
+    command: >-
+      bash scripts/distill/di4c.sh --model mdlm_di4c --dataset lm1b
+      --teacher-family masked_mdlm
+      --teacher-checkpoint checkpoints/reference_reproduction/flm_baselines/lm1b/lm1b_MDLM_.ckpt
+      --output checkpoints/reference_reproduction/mdlm_di4c/lm1b
+      --student-init teacher
+      --upstream-override is_di4c=true
+    output: checkpoints/reference_reproduction/mdlm_di4c/lm1b
+    sampling_checkpoint: student_checkpoints/20000.ckpt
+    sampling_config: config.yaml
+    prerequisites: [flm_lm1b_reproductions]
+    note: Task 12's repository wrapper must adapt the BERT masked teacher to the absorbing Di4C shape; Zenodo contains OWT students only.
+coverage:
+  - {model: langflow, dataset: lm1b, resource: langflow_lm1b_hf}
+  - {model: langflow, dataset: owt, resource: langflow_owt_hf}
+  - {model: duo, dataset: lm1b, resource: flm_lm1b_reproductions, path: lm1b_Duo.ckpt, teacher_family: uniform_duo}
+  - {model: duo, dataset: owt, resource: duo_owt_hf}
+  - {model: duo_dcd, dataset: owt, resource: duo_dcd_owt_hf}
+  - {model: mdlm, dataset: lm1b, resource: flm_lm1b_reproductions, path: lm1b_MDLM_.ckpt, teacher_family: masked_mdlm}
+  - {model: mdlm, dataset: owt, resource: mdlm_owt_hf}
+  - {model: candi, dataset: lm1b, resource: flm_lm1b_reproductions, path: lm1b_CANDI.ckpt, teacher_family: hybrid_candi}
+  - {model: rdlm, dataset: lm1b, resource: rdlm_lm1b_drive}
+  - model: mdlm_sdtt
+    dataset: owt
+    resource: sdtt_owt_hf
+    sampling_config: config.json
+    sampling_config_source: resource
+  - model: mdlm_di4c
+    dataset: owt
+    resource: di4c_mdlm_owt_zenodo
+    sampling_config: configs/sampling/di4c_mdlm_owt.yaml
+    sampling_config_source: project
+    sampling_config_sha256: cf627f89b8dede9b25ac8e10407c3b7de203a76c4ba84100723287e571dcec34
+    sampling_config_source_commit: ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3

artifacts/elf_lock.json

@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "verified_at": "2026-09-10",
+  "source": {
+    "url": "https://github.com/lillian039/ELF.git",
+    "branch": "pytorch_elf",
+    "commit": "b29d8833609e9ab7f67cd9da39435ac5cea04837"
+  },
+  "assets": {
+    "owt": {"repo_id": "embedded-language-flows/ELF-B-owt-torch", "revision": "146f84133c1389bfd4ef47f14ec7a955da22faa7", "repo_type": "model", "patterns": ["checkpoint_95085", "config.yml"], "checkpoint": "checkpoint_95085"},
+    "wmt14": {"repo_id": "embedded-language-flows/ELF-B-de-en-torch", "revision": "93ce98315a2dec985cdefb8d8e62ab618e896ec4", "repo_type": "model", "patterns": ["checkpoint_880600", "config.yml"], "checkpoint": "checkpoint_880600"},
+    "xsum": {"repo_id": "embedded-language-flows/ELF-B-xsum-torch", "revision": "aca4abd1c7ff5f841f0e2a3ec8a18b0a927927f1", "repo_type": "model", "patterns": ["checkpoint_39800", "config.yml"], "checkpoint": "checkpoint_39800"},
+    "t5": {"repo_id": "google-t5/t5-small", "revision": "df1b051c49625cf57a3d0d8d3863ed4d13564fe4", "repo_type": "model", "patterns": ["config.json", "model.safetensors", "spiece.model", "tokenizer.json", "tokenizer_config.json"]},
+    "gpt2": {"repo_id": "gpt2", "revision": "607a30d783dfa663caf39e06633721c8d4cfcd7e", "repo_type": "model", "patterns": ["config.json", "tokenizer.json", "tokenizer_config.json", "vocab.json", "merges.txt"]},
+    "gpt2-large": {"repo_id": "gpt2-large", "revision": "32b71b12589c2f8d625668d2335a01cac3249519", "repo_type": "model", "patterns": ["config.json", "model.safetensors", "tokenizer.json", "tokenizer_config.json", "vocab.json", "merges.txt"]},
+    "wmt14-official-validation": {"repo_id": "embedded-language-flows/wmt14_de-en_validation_t5", "revision": "bcc92bda4b07c329354843724c9d9ea740f30685", "repo_type": "dataset", "patterns": ["*.arrow", "*.json"]},
+    "xsum-official-validation": {"repo_id": "embedded-language-flows/xsum_validation_t5", "revision": "b0b4f5de92434d308eceeb9e38fd3f8d7d2b6a9e", "repo_type": "dataset", "patterns": ["*.arrow", "*.json"]},
+    "wmt14-raw": {"repo_id": "wmt/wmt14", "revision": "b199e406369ec1b7634206d3ded5ba45de2fe696", "repo_type": "dataset", "patterns": ["de-en/validation-*.parquet", "de-en/test-*.parquet"]},
+    "xsum-raw": {"repo_id": "EdinburghNLP/xsum", "revision": "7d4d486c2f8ef850b1a11aead99b894ff3dd7da9", "repo_type": "dataset", "patterns": ["data/validation-*.parquet", "data/test-*.parquet"]}
+  }
+}

artifacts/source_lock.json

@@ -0,0 +1,37 @@
+{
+  "manifest_sha256": "b7b0b94f1f7dfcd037110fca3d3b7f0163b551985a542efc0d014d689fde6a4d",
+  "sources": {
+    "candi": {
+      "commit": "cd57ae9eec98d6ac71cd52bdc50eeec8dfd70f91",
+      "url": "https://github.com/patrickpynadath1/candi-diffusion.git"
+    },
+    "di4c": {
+      "commit": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+      "url": "https://github.com/sony/di4c.git"
+    },
+    "duo": {
+      "commit": "7c9b498f5b717de064d6fad7e2509c866e6cb620",
+      "url": "https://github.com/s-sahoo/duo.git"
+    },
+    "flm": {
+      "commit": "a1918d5164e5038e37d0b7a4fb2010ce75b863b3",
+      "url": "https://github.com/david3684/flm.git"
+    },
+    "langflow": {
+      "commit": "a712b08570c56c787d6ef24f8e906a2dcdf768f5",
+      "url": "https://github.com/nealchen2003/LangFlow.git"
+    },
+    "mdlm": {
+      "commit": "c112c526d193436838c98d81455ee51f90309470",
+      "url": "https://github.com/kuleshov-group/mdlm.git"
+    },
+    "rdlm": {
+      "commit": "67443aa6a2d0fa981eb7c6105f9cbc563e59c5c1",
+      "url": "https://github.com/harryjo97/RDLM.git"
+    },
+    "sdtt": {
+      "commit": "1150985e90b8f2d5749e4469d5154eff9ec922c4",
+      "url": "https://github.com/jdeschena/sdtt.git"
+    }
+  }
+}

data/processed/.builder-cache/owt/validation/generator/default-bec011984d977746/0.0.0/dataset_info.json

@@ -0,0 +1 @@
+{"description": "", "citation": "", "homepage": "", "license": "", "features": {"input_ids": {"feature": {"dtype": "uint16", "_type": "Value"}, "length": 1024, "_type": "Sequence"}}, "builder_name": "generator", "dataset_name": "generator", "config_name": "default", "version": {"version_str": "0.0.0", "major": 0, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 226344960, "num_examples": 110520, "dataset_name": "generator"}}, "download_checksums": {}, "download_size": 0, "dataset_size": 226344960, "size_in_bytes": 226344960}

data/processed/owt-gpt2-1024/dataset_dict.json

@@ -0,0 +1 @@
+{"splits": ["train", "validation"]}

docs/01_sources_and_availability.md

@@ -0,0 +1,35 @@
+# 01. 源码与可用性
+
+## 服务器端下载
+
+源码仓库由 `artifacts/sources.yaml` 固定 URL 和 40 位 commit。服务器执行：
+
+```bash
+export DLB_ROOT="$PWD"
+conda activate dlb-bootstrap
+export DLB_PYTHON="$CONDA_PREFIX/bin/python"
+bash scripts/fetch_sources.sh
+"$DLB_PYTHON" scripts/verify_sources.py --root "$DLB_ROOT"
+```
+
+`fetch_sources.sh` 优先使用 `DLB_PYTHON`，否则使用 `PYTHON_BIN`、当前 Conda 环境的 `python`、PATH 中的 `python` 或 `python3`。脚本会拒绝 origin 不一致、脏工作树和未处于锁定 commit 的 checkout。`upstreams/` 是只读依赖；必要兼容修复只能放入 `patches/<source>/`，不能直接改上游目录。
+
+## 公开可用性
+
+注册表 `configs/experiments.yaml` 是唯一的 coverage 来源：
+
+- `supported` cell 才会进入 generation matrix。
+- `langflow/lm1b` 和 `langflow/owt` 使用官方 Hugging Face checkpoint，并进入 many-step generation matrix。
+- `rdlm/owt` unsupported：官方 RDLM release 没有 OWT model。
+
+unsupported 不是失败，也不能使用另一个数据集或另一个 teacher 替代。矩阵生成后再次确认：
+
+```bash
+python -m dlb.matrix --root "$DLB_ROOT" \
+  --output "$DLB_ROOT/results/matrix/generation.tsv"
+cat "$DLB_ROOT/results/matrix/unsupported.tsv"
+```
+
+## 不在本地做的事
+
+本地 worktree 不运行 `fetch_sources.sh`、`fetch_data.py`、`fetch_checkpoints.py` 的真实下载，不创建 GPU 环境，不训练，不生成 1,024 样本。提交 GitHub 后，在服务器 clone 同一 commit 执行上述命令。

docs/02_datasets.md

@@ -0,0 +1,36 @@
+# 02. 数据下载与预处理
+
+## 固定数据契约
+
+| 数据集 | Hub revision | tokenizer | 长度 | split |
+|---|---|---|---:|---|
+| LM1B | `billion-word-benchmark/lm1b@35161838ea9e05371a25a8db037f94fcae4c2064` | `bert-base-uncased` | 128 | `train` 与 `test` |
+| OWT | `Skylion007/openwebtext@79d93d786212f7344586290adb811d4ae6a1762c` | `gpt2` | 1024 | 最后 100,000 篇为 validation |
+
+LM1B 的 parquet revision、tokenizer revision、词表大小和文件校验均在 `artifacts/data.yaml`。OWT 约 8,013,769 篇文档，开始前需要至少 55 GiB 可用空间；只有明确使用 `--allow-low-disk` 才会绕过预检，并在 manifest 中留下证据。
+
+## 下载、预处理和校验
+
+以下命令只在服务器执行：
+
+```bash
+python scripts/fetch_data.py --root "$DLB_ROOT"
+python scripts/preprocess_data.py --root "$DLB_ROOT" --dataset all
+python scripts/verify_data.py --root "$DLB_ROOT" --dataset all
+```
+
+下载使用固定 Hub revision 和服务器本地 `data/raw/huggingface/` cache，可中断后重跑。预处理结果位于：
+
+```text
+data/processed/lm1b-bert-128/
+data/processed/owt-gpt2-1024/
+data/manifests/downloads.json
+data/manifests/lm1b.json
+data/manifests/owt.json
+```
+
+预处理会添加对应 tokenizer 的 BOS/EOS 语义并保证每个 packed sequence 长度严格一致。不要手动改 split、长度、tokenizer 或 OWT validation 边界；否则训练 recipe 和指标不再可比。
+
+## 失败恢复
+
+若 `verify_data.py` 报错，保留 `data/manifests/` 和日志，先检查磁盘、Hub cache 和 revision，再重新执行对应阶段。不要把不完整的 `data/processed/*` 改名为完成目录。

docs/06_generation_and_evaluation.md

@@ -0,0 +1,79 @@
+# 06. 生成、评测与 timing
+
+## 生成矩阵
+
+先生成并检查 TSV：
+
+```bash
+python -m dlb.matrix --root "$DLB_ROOT" \
+  --output "$DLB_ROOT/results/matrix/generation.tsv" \
+  --sample-count 1024 --seed 42
+python -m dlb.matrix --root "$DLB_ROOT" \
+  --output "$DLB_ROOT/results/matrix/generation.tsv" --validate
+```
+
+完整生成：
+
+```bash
+bash scripts/run_all.sh --root "$DLB_ROOT"
+```
+
+它会逐行继续执行，即使一个 cell 失败也会记录 `results/logs/generation_failures.tsv`。每个成功目录包含 `samples.jsonl`、`run_metadata.json`、`request.json` 和 stdout/stderr；runner 只有在样本 schema 和数量均通过后才写成功标记。
+
+单个 cell：
+
+```bash
+bash scripts/run_one.sh --model mdlm --dataset owt --steps 32 \
+  --num-samples 1024 --seed 42
+```
+
+smoke：
+
+```bash
+bash scripts/smoke_all.sh
+```
+
+smoke 输出在 `results/smoke/`，sample_count=1 的 identity 不会被正式聚合接受。
+
+## 三项质量指标
+
+```bash
+bash scripts/evaluate_all.sh --root "$DLB_ROOT"
+```
+
+评测环境必须能读取固定 revision 的 `gpt2-large`。正式评测不允许 `--allow-partial` 或自定义 special-id；LM1B 只排除约定的 padding，保留 BOS/EOS 语义。输出为每个 cell 的 `results/metrics/.../metrics.json`，包含样本 SHA、sample_count、PPL、unigram entropy 和 Self-BLEU。
+
+## 独立 latency
+
+主 latency 协议固定为 batch size 1、5 warm-up、32 repetitions、CUDA synchronize；加载、首次编译、decode、指标计算和落盘不计入。单个 cell：
+
+```bash
+bash scripts/benchmark_one.sh --model flm --dataset lm1b --steps 32 \
+  --seed 42 --precision author
+```
+
+批量执行：
+
+```bash
+bash scripts/benchmark_all.sh --root "$DLB_ROOT"
+```
+
+timing 输出在 `results/timing/.../timing.json`，`seconds_per_sample` 是主汇总字段；不要使用样本里的 `generation_seconds` 替代它。
+
+## 严格汇总
+
+```bash
+python scripts/aggregate_results.py --root "$DLB_ROOT"
+```
+
+严格模式要求全部 132 个 supported task 都有 1,024 样本、三项质量指标、独立 timing 和匹配 provenance，输出：
+
+```text
+results/summary/results_long.csv
+results/summary/results_wide.csv
+results/summary/failures.csv
+results/summary/unsupported.csv
+results/summary/README.md
+```
+
+未完成时用 `--partial` 诊断；partial 报告必须标记 `complete=false`，不能作为最终论文表。

docs/07_slurm.md

@@ -0,0 +1,39 @@
+# 07. Slurm
+
+Slurm 模板不硬编码 partition、GPU 型号、walltime 或内存。请根据服务器站点在提交命令上补充这些资源参数；模板通过注册表 TSV 的 `environment` 字段选择 Conda 环境。
+
+## 生成 array
+
+先在登录节点创建矩阵，再提交 132 个 array task：
+
+```bash
+python -m dlb.matrix --root "$DLB_ROOT" \
+  --output "$DLB_ROOT/results/matrix/generation.tsv"
+sbatch --array=0-131%8 slurm/generate_array.sbatch
+```
+
+## 质量评测和 timing
+
+```bash
+sbatch slurm/evaluate.sbatch
+sbatch --array=0-131%8 slurm/benchmark_array.sbatch
+```
+
+`evaluate.sbatch` 使用 `DLB_EVAL_ENV`（默认 `dlb-eval`）；array 模板读取每一行的模型、数据集、steps 和 registry environment，不根据 task id 猜环境。
+
+## 训练/蒸馏
+
+通过环境变量指定 recipe：
+
+```bash
+DLB_RECIPE=candi DLB_DATASET=owt \
+  sbatch --gres=gpu:1 slurm/train.sbatch
+DLB_RECIPE=di4c DLB_MODEL=duo_di4c DLB_DATASET=lm1b \
+  sbatch --gres=gpu:1 slurm/train.sbatch
+```
+
+如站点需要 partition、constraint、时间或内存，请加到 `sbatch` 命令，而不是修改模板中的固定值。大训练任务的 devices/nodes 通过 `DLB_TRAIN_DEVICES`、`DLB_TRAIN_NODES` 或 recipe 命令参数设置，必须保持锁定 global batch。
+
+## 日志与重试
+
+Slurm 输出在 `results/logs/slurm-*.out`/`.err`；单个 array task 失败可只重提对应 index。不要删除成功样本或 timing 后盲目重跑，先核对 `run_metadata.json`、`checkpoint_lock.json` 和失败日志。

docs/09_four_gpu_local.md

@@ -0,0 +1,75 @@
+# 09. 4-GPU 本地并行运行
+
+本路径适用于单机服务器直接用 Bash/Conda 跑实验，不依赖 Slurm。默认只使用
+GPU `0,1,2,3`，并且最多同时运行 4 个 matrix task。
+
+## 默认资源策略
+
+- 生成、smoke 和 benchmark：每个 task 绑定 1 张 GPU。
+- 评测：每个 task 绑定 1 张 GPU，GPT-2 Large PPL 在该 GPU 上计算。
+- 绑定方式：对子进程设置 `CUDA_VISIBLE_DEVICES=<gpu_id>`。子进程内看到的设备通常是 `cuda:0`。
+- 默认并发：`DLB_MAX_JOBS=4`。
+
+可以覆盖 GPU 列表或并发数：
+
+```bash
+DLB_GPUS=0,1,2,3 DLB_MAX_JOBS=4 bash scripts/run_4gpu.sh
+DLB_GPUS=0,1 DLB_MAX_JOBS=2 bash scripts/run_4gpu.sh
+```
+
+## 推荐顺序
+
+先完成 README 中的源码、数据、checkpoint 和 Conda 环境准备。需要
+`reference_reproduction` 的 checkpoint 时，先按 `docs/05_training.md` 训练或蒸馏
+对应产物。
+
+然后执行：
+
+```bash
+export DLB_GPUS=0,1,2,3
+export DLB_MAX_JOBS=4
+
+bash scripts/smoke_4gpu.sh
+bash scripts/run_4gpu.sh
+bash scripts/evaluate_4gpu.sh
+bash scripts/benchmark_4gpu.sh
+"$DLB_PYTHON" scripts/aggregate_results.py --root "$DLB_ROOT"
+```
+
+## 输出
+
+- smoke 样本：`results/smoke/samples/...`
+- 正式样本：`results/samples/<dataset>/<model>/steps_<steps>/samples.jsonl`
+- 指标：`results/metrics/<dataset>/<model>/steps_<steps>/metrics.json`
+- timing：`results/timing/<dataset>/<model>/steps_<steps>/timing.json`
+- 汇总表：`results/summary/results_wide.csv` 和 `results/summary/results_long.csv`
+
+每个 task 的 stdout/stderr 会写入：
+
+```text
+results/logs/4gpu-<stage>-<task_id>.out
+results/logs/4gpu-<stage>-<task_id>.err
+```
+
+失败清单按阶段写入：
+
+```text
+results/logs/smoke_4gpu_failures.tsv
+results/logs/generation_4gpu_failures.tsv
+results/logs/evaluation_4gpu_failures.tsv
+results/logs/benchmark_4gpu_failures.tsv
+```
+
+如果失败清单不存在，表示该阶段没有失败 task。
+
+## Dry Run
+
+在真正占用 GPU 前可以检查调度计划：
+
+```bash
+bash scripts/run_4gpu.sh --dry-run
+bash scripts/evaluate_4gpu.sh --dry-run
+bash scripts/benchmark_4gpu.sh --dry-run
+```
+
+dry-run 会输出每个 task 绑定的 GPU 和实际 argv，不启动模型。

docs/12_elf_condition_recovery.md

@@ -0,0 +1,146 @@
+# ELF 正式条件实验中断：诊断和继续运行
+
+**本页为故障诊断期间的历史步骤，现由 [文档 13：已确认的 EOS 修复与恢复](13_elf_eos_fix.md) 替代。** 用户提供的 audit 已证明唯一配对样本的作者条件等于 raw tokens 加 EOS。现在采用修复后的原始输入流程，不必再按本页切换作者全集；已有作者结果保留。
+
+2026-09-12 最新日志显示：WMT14 连续完成了若干个 3000 样本格子，BLEU 为 13.4014、14.0021、14.1667；随后 XSum 在 `216/11332 samples` 后报 `ValueError: Empty condition`。这份恢复步骤优先于文档 11 中使用原始 `validation/test` 的条件实验命令。
+
+**已确认的问题与尚未确认的原因**
+
+- XSum 中断发生在下一批（零基索引 216–223）准备输入时：至少一行得到空的条件 token 列表。仅凭日志不能确定确切行号或是空字符串、空白字符还是分词后为空；新诊断会列出全部空条件 ID。
+- `1069 > 512` 是 T5 tokenizer 的长度提示，不是这次异常。当前 ELF XSum 配置将 source 截到 1024，总 canvas 为 1088。不要把 source 上限改成 512 来消除提示，那会改变实验。新预检查使用 `verbose=False` 做完整分词，再沿用原有模型截断上限。
+- WMT14 的 BLEU≈13–14 明显低于之前 official-validation sanity 的 25.79，需调查原始文本与作者条件 IDs 的差异。此次日志没有格子的步数标签；按此前循环顺序，最后完成的是 64 步，但应以 `request.json` 为准。不能把该降幅直接归为正常采样误差，也不能凭日志断定唯一原因是 EOS。
+- 旧 `prepare` 对官方输入使用 `condition_input_ids`，对原始输入使用 `add_special_tokens=False` 重新分词。这与锁定版本的[官方 JSONL loader](https://github.com/lillian039/ELF/blob/b29d8833609e9ab7f67cd9da39435ac5cea04837/src/utils/data_utils.py#L121-L137)一致，但不能据此证明与发布的 Arrow tokens 等价。作者预处理 validation 才是[发布配置默认使用的数据](https://github.com/lillian039/ELF/blob/b29d8833609e9ab7f67cd9da39435ac5cea04837/README.md)。
+
+此前从 sanity 直接切换原始 validation 全集的安排，缺少逐样本输入一致性核验。这次先补核验，并用已下载的作者 validation 全集建立 ELF 基线。原始 validation/test 暂停，不删空样本、不添加虚构 source、不猜测性插入 EOS。已有低分格子保留为待调查的原始输入协议结果；作者数据结果单独存放，不混成一条曲线。
+
+**1．更新代码、恢复单张物理 GPU 2 环境**
+
+新版本在加载 ELF 权重前扫描本次全部条件输入，空条件会报告数量和行号并提前退出，避免再生成几百条才失败。有效输入的 tokens、截断、采样器和指标没有改变。OWT 已成功完成的质量结果无需重跑。
+
+```bash
+cd ~/diffusion_baseline
+git pull --ff-only origin main
+conda activate dlb-elf
+export DLB_ROOT="$PWD"
+export ELF_PYTHON="$CONDA_PREFIX/bin/python"
+export PYTHONDONTWRITEBYTECODE=1
+export ELF_PHYSICAL_GPU=2
+export ELF_GPU_UUID="$(nvidia-smi -i "$ELF_PHYSICAL_GPU" --query-gpu=uuid --format=csv,noheader)"
+export CUDA_VISIBLE_DEVICES="$ELF_GPU_UUID"
+export ELF_RESULTS="$DLB_ROOT/results/elf-h200-gpu2-official-v1"
+export ELF_BATCH_SIZE=8 ELF_EVAL_BATCH_SIZE=8 ELF_SEED=42 ELF_COMPILE=0
+unset ELF_STEPS ELF_COUNT ELF_SPLIT ELF_TIMING_PROMPT
+mkdir -p "$ELF_RESULTS/logs" "$ELF_RESULTS/environment"
+set -o pipefail
+runlog() {
+  local label="$1"
+  shift
+  "$@" 2>&1 | tee "$ELF_RESULTS/logs/$label.log"
+}
+nvidia-smi -i "$ELF_GPU_UUID" > "$ELF_RESULTS/environment/gpu-before.txt"
+```
+
+失败的原始 XSum 目录包含 `samples.jsonl.tmp`，不是完整结果，也不能直接从第 217 条拼接续跑：脚本没有保存该位置的完整 RNG 状态。保留该目录，本次使用新的根目录和 `official-validation` split；不要移动或删除旧结果来伪装恢复。
+
+**2．CPU 诊断，并核对之前各格子的任务与步数**
+
+不下载数据、不加载模型权重、不占 GPU 推理。读取服务器现有 JSONL、manifest 和本地 T5 tokenizer：
+
+```bash
+runlog input_audit python scripts/audit_elf_inputs.py \
+  --output "$ELF_RESULTS/input-audit.json"
+
+python scripts/summarize_elf.py \
+  --results "$DLB_ROOT/results/elf-h200-gpu2" \
+  --output "$DLB_ROOT/results/elf-h200-gpu2/summary-before-recovery.csv"
+
+python - <<'PY'
+import json, os
+from pathlib import Path
+root = Path(os.environ['DLB_ROOT']) / 'results/elf-h200-gpu2/quality'
+for path in sorted(root.rglob('request.json')):
+    request = json.loads(path.read_text())
+    metrics = path.with_name('metrics.json')
+    m = json.loads(metrics.read_text()) if metrics.exists() else {}
+    print(request['task'], (request.get('input') or {}).get('split', 'unconditional'),
+          'steps=', request['steps'], 'valid=', m.get('valid'),
+          'BLEU=', m.get('metrics', {}).get('bleu'), str(path.parent))
+PY
+```
+
+报告重点：`raw.empty_condition_ids`、`official.empty_condition_ids`、按 source/reference 文本配对后的 `exact_ids_after_source_cap`、`raw_plus_eos_equals_official`、`mismatch_examples`。匹配按完整文本对进行，不假设两个数据集同一行号就是同一样本；无法匹配或重复匹配的行也会计数。EOS 对比只是诊断，不会修改 token。将 `logs/input_audit.log` 提供给我，用它确定原始 validation/test 的后续预处理修复。
+
+**3．先跑作者 validation 全集的 64 步标准点**
+
+先检查诊断成功且作者输入全部非空；通过后运行 WMT14 3000 条、XSum 11332 条。之前 sanity 是独立目录的 1000 条，这里是全集，不会覆盖它。
+
+```bash
+(
+  set -e
+  python - <<'PY'
+import json, os
+from pathlib import Path
+r = json.loads((Path(os.environ['ELF_RESULTS']) / 'input-audit.json').read_text())
+for task in ('wmt14', 'xsum'):
+    assert r['tasks'][task]['official_conditions_nonempty'], (
+        task, r['tasks'][task]['official']['empty_condition_ids'])
+print('Official validation conditions are nonempty; generation will recheck input hashes.')
+PY
+  for task in wmt14 xsum; do
+    runlog "${task}_official_s64_generate" \
+      env ELF_COUNT=0 ELF_STEPS=64 ELF_SPLIT=official-validation \
+      bash scripts/run_elf_suite.sh generate "$task"
+    runlog "${task}_official_s64_evaluate" \
+      env ELF_STEPS=64 ELF_SPLIT=official-validation \
+      bash scripts/run_elf_suite.sh evaluate "$task"
+  done
+)
+```
+
+先看 64 步的 BLEU/ROUGE 是否回到 sanity 的量级。全集与前 1000 条分数可以不同，不设置为了“通过”而调参的分数门槛；如果仍明显偏低，先提供这两个指标与 audit 日志，暂不跑第 4 步的全量扫描。若 preflight 仍报错，保留错误信息，不绕过它。这里的结果应标为 **official-validation 全集**，不能称 test 结果。
+
+**4．标准点合理后，补 8/16/32 步质量**
+
+```bash
+(
+  set -e
+  for task in wmt14 xsum; do
+    for steps in 8 16 32; do
+      runlog "${task}_official_s${steps}_generate" \
+        env ELF_COUNT=0 ELF_STEPS="$steps" ELF_SPLIT=official-validation \
+        bash scripts/run_elf_suite.sh generate "$task"
+      runlog "${task}_official_s${steps}_evaluate" \
+        env ELF_STEPS="$steps" ELF_SPLIT=official-validation \
+        bash scripts/run_elf_suite.sh evaluate "$task"
+    done
+  done
+)
+```
+
+**5．同一张 H200 独占时测 timing**
+
+不要与 generation/evaluate 并行；确认 GPU 2 没有其他计算任务。条件 timing 与本次质量统一使用 `official-validation`，固定 batch=1，5 次预热、32 次测量，第 0 条输入。OWT 不受这次条件输入问题影响。
+
+```bash
+nvidia-smi -i "$ELF_GPU_UUID"
+(
+  set -e
+  nvidia-smi -i "$ELF_GPU_UUID" > "$ELF_RESULTS/environment/gpu-before-timing.txt"
+  runlog owt_core_timing env ELF_STEPS="8 16 32 64" \
+    bash scripts/run_elf_suite.sh timing owt
+  for task in wmt14 xsum; do
+    runlog "${task}_official_core_timing" \
+      env ELF_STEPS="8 16 32 64" ELF_SPLIT=official-validation \
+      bash scripts/run_elf_suite.sh timing "$task"
+  done
+  nvidia-smi -i "$ELF_GPU_UUID" > "$ELF_RESULTS/environment/gpu-after-timing.txt"
+)
+python scripts/summarize_elf.py \
+  --results "$ELF_RESULTS" --output "$ELF_RESULTS/summary.csv"
+```
+
+OWT 质量仍在旧根目录，以上 OWT timing 在新根目录；汇总时按任务/步数/seed/配置匹配，保留两边 provenance。条件任务看 `results.encoder_plus_sampler.seconds_per_sample`（含 T5 编码）及 `results.sampler_cached_condition.seconds_per_sample`（缓存编码）；OWT 看 `results.sampler.seconds_per_sample`。这些不含模型加载、CPU 分词、指标计算和 IO；第 0 条重复测量不代表全数据集平均服务延迟。
+
+**6．后续实验**
+
+OWT 前缀实验仍可按文档 11 的 F 准备和运行，不受 WMT14/XSum 输入问题影响。原始 validation/test 的正式恢复取决于本次 audit 的实证结果；不能将作者 validation 冒充 test，也不能删除空数据后继续声称原始全集。现在先取得可信的作者 validation 质量与 timing 基线，再完成原始集协议核验和 test。

docs/13_elf_eos_fix.md

@@ -0,0 +1,178 @@
+# ELF 条件输入 EOS 修复与正式实验恢复
+
+本页取代文档 12 中“原始 validation/test 暂停、先改跑作者全集”的临时安排。现有 JSONL、权重、环境无需重新准备；修复发生在 runner 的条件分词阶段，结果使用新目录 `results/elf-h200-gpu2-eos-v2`。
+
+**诊断已经确认什么**
+
+用户提交的服务器 audit 显示：WMT14 的 2992 条唯一文本对、XSum 的全部 11332 条，作者保存的条件 IDs 都严格等于 `raw_no_special_tokens + [EOS]`。EOS ID 为 1（`</s>`）。WMT14 剩余 8 条是重复文本对，旧诊断没有唯一配对；新诊断通过包含重复次数的完整记录比较覆盖它们，不会删除重复样本。
+
+XSum 的 source ID **219、3834、4715、5677、8445** 是空白文本；旧路径返回 `[]`，作者路径是 `[1]`，所以原始实验在准备含第 219 行的 batch 时中断，而作者 sanity 能通过。EOS 属于输入编码格式，并非补写文章内容；这五条仍保留完整 reference 并参与评测。
+
+WMT14 旧输入缺 EOS 的协议错误已确认，是质量下降的重要解释；是否足以恢复 BLEU，要以修正后实测为准，不能声称已经恢复 26 分。此前依据官方 JSONL loader 的无特殊 token 写法没有复现发布 Arrow 的编码，现根据实际发布数据修正。
+
+**修复规则**
+
+- WMT14/XSum 原始文本：完整分词后追加一个 EOS，再截到 source 上限 64/1024；不能先截断再强行补 EOS，也不能预留一个位置替换长文本的最后一个正文 token。
+- 已有 `condition_input_ids`：原样使用，不再添加 EOS；已有 official-validation 生成结果不受影响。
+- OWT unconditional 与 OWT 前缀续写：保留原协议。前缀续写不是已结束的 source 文本，不能套用这次 EOS 改动。
+- `request.json`、`generation.json`、`timing.json` 记录 `condition_tokenization_policy=released_ids_or_raw_plus_eos_then_source_cap_v2`，汇总 CSV 也保留该字段。旧结果缺这个字段，不能仅按 task/steps 与新结果混用。
+
+**1．同步代码并绑定物理 GPU 2**
+
+最新服务器日志中的 `fatal: Cannot fast-forward to multiple branches.` 表明 pull 的整合阶段失败；随后继续使用旧 audit，虽然输出文件名叫 `input-audit-v2.json`，内部 schema 仍是 v1，触发了断言。由于实验块有 `set -e`，本次尚未启动 64 步生成。这不是 EOS 修复再次失效。仅凭日志不能确定为什么出现多个合并目标；先显式抓取和合并唯一的远端 main，不使用可能包含多个候选的 FETCH_HEAD，也不重置本地工作。
+
+先单独执行同步块，看到 `ELF EOS code sync OK` 后再执行下面环境设置。Git pull 本身包含抓取和整合两个阶段，因此“显示抓取到 main”不代表工作区更新成功。[Git 文档](https://git-scm.com/docs/git-pull)
+
+```bash
+(
+  set -e
+  cd ~/diffusion_baseline
+  git status --short
+  test "$(git branch --show-current)" = main
+  git fetch --no-tags origin refs/heads/main:refs/remotes/origin/main
+  git merge --ff-only refs/remotes/origin/main
+  git merge-base --is-ancestor 1b253e6 HEAD
+  git diff --exit-code HEAD -- scripts/elf_common.py scripts/audit_elf_inputs.py scripts/run_elf.py
+  git log -1 --oneline
+  printf '%s\n' 'ELF EOS code sync OK'
+)
+```
+
+若此块仍失败，停止并保留报错；不要继续 audit/generate。无须重新克隆、下载资源或删除结果。服务器有本地修改或分支分叉时，以上命令不会强行覆盖它们。
+
+```bash
+cd ~/diffusion_baseline
+conda activate dlb-elf
+export DLB_ROOT="$PWD"
+export ELF_PYTHON="$CONDA_PREFIX/bin/python"
+export PYTHONDONTWRITEBYTECODE=1
+export ELF_PHYSICAL_GPU=2
+export ELF_GPU_UUID="$(nvidia-smi -i "$ELF_PHYSICAL_GPU" --query-gpu=uuid --format=csv,noheader)"
+export CUDA_VISIBLE_DEVICES="$ELF_GPU_UUID"
+export ELF_RESULTS="$DLB_ROOT/results/elf-h200-gpu2-eos-v2"
+export ELF_BATCH_SIZE=8 ELF_EVAL_BATCH_SIZE=8 ELF_SEED=42 ELF_COMPILE=0
+unset ELF_STEPS ELF_COUNT ELF_SPLIT ELF_TIMING_PROMPT
+mkdir -p "$ELF_RESULTS/logs" "$ELF_RESULTS/environment"
+set -o pipefail
+runlog() {
+  local label="$1"
+  shift
+  "$@" 2>&1 | tee "$ELF_RESULTS/logs/$label.log"
+}
+nvidia-smi -i "$ELF_GPU_UUID" > "$ELF_RESULTS/environment/gpu-before.txt"
+```
+
+**GPU 2 上的小进程是否影响实验**
+
+2026-09-12 14:56 的快照显示总显存约 97 MiB / 143771 MiB、GPU 利用率 0%，有三个同伴的 Python CUDA 进程。当前显存压力很低，可以先运行质量生成与评测；共享运行主要可能拖慢完成时间，如果其他进程后来增加显存也可能导致 OOM。共享本身通常不会改变 BLEU/ROUGE/PPL 的计算口径，不用因此作废成功完成的质量结果。
+
+显存大小不是算力占用指标；0% 也只对应采样窗口。正式 timing 需要与同伴约定 GPU 独占时段，其他任务可能间歇启动 kernel，影响延迟和抖动，目前无法从快照量化影响百分比。[NVIDIA-SMI 指标说明](https://docs.nvidia.com/deploy/nvidia-smi/index.html)
+
+可在另一个终端观察 30 次每秒的进程利用率；`-` 代表指标不可用，不代表零占用。观察只能了解负载，不能保证随后的整个 timing 窗口独占：
+
+```bash
+nvidia-smi pmon -i 2 -s um -d 1 -c 30
+```
+
+**2．CPU 检查实际修复路径，再跑 64 步 validation 全集**
+
+更新后的诊断会保留旧 `raw` 统计用于对照，所以其中仍显示 5 个空列表是预期的。真正判定修复的是新增的 `corrected_runner_comparison_including_duplicates`：`empty_condition_ids=[]`、`ready_for_raw_validation=true`。完整 token 比较和截断后比较会分别报告，并检查顺序是否一致。它调用 runner 共用的分词函数，不是仅对 EOS 做一个假设性比较。
+
+以下整块先做 CPU 检查，通过后才加载 GPU 模型。两项分别生成全部 3000/11332 条；参考答案不参与条件编码。
+
+本次旧 audit 在 schema 断言处就停止了，因此同步成功后可以直接重跑下块、沿用 `elf-h200-gpu2-eos-v2` 目录。诊断 JSON 会更新成 v2；无需清空整个结果目录。如果后来另外启动过生成，则仍需先检查相应格子是否已完成，避免重复运行。
+
+```bash
+(
+  set -e
+  runlog input_audit_v2 python scripts/audit_elf_inputs.py \
+    --output "$ELF_RESULTS/input-audit-v2.json"
+  python - <<'PY'
+import json, os
+from pathlib import Path
+r = json.loads((Path(os.environ['ELF_RESULTS']) / 'input-audit-v2.json').read_text())
+assert r['schema'] == 'elf-condition-audit-v2'
+for task in ('wmt14', 'xsum'):
+    c = r['tasks'][task]['corrected_runner_comparison_including_duplicates']
+    print(task, c)
+    assert c['ready_for_raw_validation'], f'{task}: 修复后的条件与作者数据仍不一致，请保留报告'
+print('条件输入核验通过，开始 64 步 validation 全集')
+PY
+  for task in wmt14 xsum; do
+    runlog "${task}_val_s64_generate" \
+      env ELF_COUNT=0 ELF_STEPS=64 ELF_SPLIT=validation \
+      bash scripts/run_elf_suite.sh generate "$task"
+    runlog "${task}_val_s64_evaluate" \
+      env ELF_STEPS=64 ELF_SPLIT=validation \
+      bash scripts/run_elf_suite.sh evaluate "$task"
+  done
+)
+```
+
+先看 WMT14 BLEU 和 XSum ROUGE 是否回到先前 sanity 的合理量级；全集与前 1000 条允许有抽样差异。如果仍明显异常，先提供这两项指标和 audit v2，不继续扩展扫描。无需再次跑 1000 条 sanity 或重复作者全集；如果作者全集已启动，先让它完成或正常停止，勿在同一 GPU 同时启动本节。
+
+**3．64 步质量确认后，重跑原始 validation 的 8/16/32 步**
+
+旧 WMT14 的 13–14 分结果使用了错误的 source 编码，不能只重算指标，必须重新生成；旧 XSum 的部分 `.tmp` 不能拼接进新结果。全部旧文件保留，不删除、不覆盖。
+
+```bash
+(
+  set -e
+  for task in wmt14 xsum; do
+    for steps in 8 16 32; do
+      runlog "${task}_val_s${steps}_generate" \
+        env ELF_COUNT=0 ELF_STEPS="$steps" ELF_SPLIT=validation \
+        bash scripts/run_elf_suite.sh generate "$task"
+      runlog "${task}_val_s${steps}_evaluate" \
+        env ELF_STEPS="$steps" ELF_SPLIT=validation \
+        bash scripts/run_elf_suite.sh evaluate "$task"
+    done
+  done
+)
+```
+
+**4．单卡独占时测修复后的条件 timing**
+
+固定 batch=1、5 次 warmup、32 次 repeats，默认第 0 条输入；不与生成/指标评测并行。旧原始输入的 timing 也使用了不同条件长度，不能替代修复后的 timing。
+
+```bash
+nvidia-smi -i "$ELF_GPU_UUID"
+(
+  set -e
+  nvidia-smi -i "$ELF_GPU_UUID" > "$ELF_RESULTS/environment/gpu-before-timing.txt"
+  for task in wmt14 xsum; do
+    runlog "${task}_val_timing" \
+      env ELF_STEPS="8 16 32 64" ELF_SPLIT=validation \
+      bash scripts/run_elf_suite.sh timing "$task"
+  done
+  nvidia-smi -i "$ELF_GPU_UUID" > "$ELF_RESULTS/environment/gpu-after-timing.txt"
+)
+```
+
+同时保留 `sampler_cached_condition` 和 `encoder_plus_sampler` 的 `seconds_per_sample`，后者包含 T5 条件编码；两者均不含加载、CPU tokenizer、IO 和指标计算。这是单输入重复测量，不是全集平均服务耗时。OWT 的质量/已有 timing 不受本次修复影响；若 OWT timing 尚未跑，可在独占时用本目录单独运行 `env ELF_STEPS="8 16 32 64" bash scripts/run_elf_suite.sh timing owt`，质量继续引用旧目录。
+
+**5．恢复 test：先冻结标准 64 步，使用同一 EOS 规则**
+
+validation 检查确认后可执行完整 WMT14 test 3003 条、XSum test 11334 条。此次 EOS 规则由作者 validation 实证确定，再应用于 test；没有作者 test token 文件用于逐行对照，因此报告“官方权重在公开 test 上按验证过的 source EOS 规则重评”，不宣称已确认论文全部 test 预处理相同。空 source 仍保留，完整 reference 不截断。
+
+```bash
+(
+  set -e
+  for task in wmt14 xsum; do
+    runlog "${task}_test_s64_generate" \
+      env ELF_COUNT=0 ELF_STEPS=64 ELF_SPLIT=test \
+      bash scripts/run_elf_suite.sh generate "$task"
+    runlog "${task}_test_s64_evaluate" \
+      env ELF_STEPS=64 ELF_SPLIT=test \
+      bash scripts/run_elf_suite.sh evaluate "$task"
+    # 此时同样要求 GPU 独占。
+    runlog "${task}_test_s64_timing" \
+      env ELF_STEPS=64 ELF_SPLIT=test \
+      bash scripts/run_elf_suite.sh timing "$task"
+  done
+)
+python scripts/summarize_elf.py \
+  --results "$ELF_RESULTS" --output "$ELF_RESULTS/summary.csv"
+```
+
+更少步数的 test 配置先根据 validation 冻结，再补测。OWT 前缀和扩展步数仍按文档 11 的 F/H2 实施；原始条件任务的相关命令使用本页的新结果根目录。任何已经成功的格子都不要原样重复 generate；若只缺指标则只 evaluate，若只缺 timing 则只 timing。

docs/19_elf_short_response_rescore.md

@@ -0,0 +1,75 @@
+# ELF OWT条件4步、8步：短输出补评分
+
+用户提供的结果：4步已生成2048条，其中2条不足64个GPT-2 tokens；8步已生成2048条，其中1条不足64个GPT-2 tokens。两格都有timing。这不是生成任务缺失或GPU报错，而是严格C64评分拒绝了短输出。仅凭CSV还不能判断是提前EOS还是T5/GPT-2重分词长度差异。
+
+保持相同seed和生成配置，重复生成不保证解决短输出；改变seed、只替换短样本或反复抽到足长样本会引入筛选。因此这次复用原始2048条，**只重新运行评分，不训练、不重新生成、不重测timing**。
+
+## 两种评分结果分开保存
+
+- `strict`（原默认）：每条response必须至少64 tokens。旧4步、8步仍为 `valid=false`，本次不覆盖。
+- `observed`（新增可选）：所有2048条都参与，长输出取前64 tokens，短输出取实际非空长度，不补padding、不丢样本。PPL仍使用GPT-2 Large并排除prompt loss，按总NLL/总实际有效response token数汇总；entropy是每条实际评分片段熵的均值。若有空response，仍不能产生完整主指标。
+
+后一种结果必须标注为“response最多64个GPT-2 tokens，短输出按实际长度评分”。它并不是把原来严格64的失败变成成功。其他5个步数没有短输出，在两种长度政策下评分片段相同；如果合并展示，整张表统一标注最多64政策，并保留每格短输出计数及原结果来源。可用 `--short-response-policy observed` 不指定 `--steps` 为全部7格生成同一协议的新表。
+
+## 服务器：只补4步和8步
+
+一张空闲GPU足够，以下使用GPU0。与ELF1024步生成无关，只加载评分器。
+
+```bash
+cd ~/diffusion_baseline
+git pull --ff-only
+conda activate dlb-elf
+export PYTHONDONTWRITEBYTECODE=1
+mkdir -p results/elf-owt-baseline-logs
+set -o pipefail
+
+python scripts/evaluate_elf_owt_baseline.py \
+  --task owt-prefix --steps 4 8 \
+  --short-response-policy observed --plan
+
+CUDA_VISIBLE_DEVICES=0 python -u scripts/evaluate_elf_owt_baseline.py \
+  --task owt-prefix --steps 4 8 \
+  --short-response-policy observed --batch-size 8 \
+  2>&1 | tee results/elf-owt-baseline-logs/owt-prefix-s4-s8-observed.log
+```
+
+`--plan`应只列出两格，不进行GPU推理。新结果默认写入独立的 `results/elf-owt-baseline-eval-owt-prefix-observed`，不需要设置ELF_RESULTS。中断后重复同一条评分命令即可，已核验的新指标会跳过。
+
+```bash
+cat results/elf-owt-baseline-eval-owt-prefix-observed/summary-steps-4-8.csv
+```
+
+预期：两格sample_count均2048；如所有短输出均非空且有有效评分目标，valid=True；short_count仍为2和1。short_count不会被“修成0”。若依然失败，保留日志，不更换seed或删样本。
+
+## 可选：查看原短输出的真实长度与文本
+
+下面只用CPU tokenizer，不加载GPU模型。读取旧指标定位样本，并校验保存的样本哈希。
+
+```bash
+python - <<'PY'
+import json, sys
+from pathlib import Path
+sys.path.insert(0, 'scripts')
+from elf_common import asset, sha256
+from transformers import AutoTokenizer
+root = Path.cwd()
+tok = AutoTokenizer.from_pretrained(str(asset(root, 'gpt2')), local_files_only=True)
+for steps in (4, 8):
+    mp = root / f'results/elf-owt-baseline-eval-owt-prefix/steps_{steps}/metrics.json'
+    meta = json.loads(mp.read_text())
+    samples = Path(meta['source_run']) / 'samples.jsonl'
+    assert sha256(samples) == meta['samples_sha256']
+    selected = set(meta['short_sample_ids'])
+    for line in samples.open():
+        row = json.loads(line)
+        if row['id'] in selected:
+            print(json.dumps({
+                'steps': steps, 'id': row['id'],
+                'prompt_id': row['prompt_id'], 'completion_id': row['completion_id'],
+                'gpt2_tokens': len(tok(row['generated'], add_special_tokens=False)['input_ids']),
+                'text': row['generated'],
+            }, ensure_ascii=False))
+PY
+```
+
+由于旧生成文件已经裁剪EOS之后的内容，本次不能从现有文件恢复完整原生输出尾部；诊断只能说明已保存文本的情况。无需为补这两个评分数字再生成整批样本。

docs/EXPERIMENT_MATRIX.md

@@ -0,0 +1,43 @@
+# 实验矩阵
+
+## 任务展开
+
+| 类别 | 逻辑方法 | 步数 | 数据集 cell | 任务数 |
+|---|---|---|---:|---:|
+| Many-step | FLM | 1,2,4,8,16,32,1024 | LM1B、OWT | 14 |
+| Many-step | LangFlow | 1,2,4,8,16,32,1024 | LM1B、OWT | 14 |
+| Many-step | Duo | 1,2,4,8,16,32,1024 | LM1B、OWT | 14 |
+| Many-step | MDLM | 1,2,4,8,16,32,1024 | LM1B、OWT | 14 |
+| Many-step | CANDI | 1,2,4,8,16,32,1024 | LM1B、OWT | 14 |
+| Many-step | RDLM | 1000,1024 | LM1B | 2 |
+| Few-step | FMLM | 1,2,4,8,16,32 | LM1B、OWT | 12 |
+| Few-step | Duo+DCD | 1,2,4,8,16,32 | LM1B、OWT | 12 |
+| Few-step | Duo+Di4C | 1,2,4,8,16,32 | LM1B、OWT | 12 |
+| Few-step | MDLM+SDTT | 1,2,4,8,16,32 | LM1B、OWT | 12 |
+| Few-step | MDLM+Di4C | 1,2,4,8,16,32 | LM1B、OWT | 12 |
+| **合计** |  |  |  | **132** |
+
+RDLM/OWT 是注册表声明的 unsupported cell，只保留一条 reason，不展开为 steps。
+RDLM/LM1B 也不展开 `1,2,4,8,16,32`：RDLM 原始 baseline 是官方 SDE sampler，默认约 1000 个数值积分步；少步网格不是论文方法，也不是训练过的蒸馏版本。服务器诊断显示这些低步 RDLM 行存在 retokenization、非规范上游 ID、低 entropy 与 PPL 非单调信号，因此主表只保留官方默认 `1000` 和与本项目旧网格对齐的 `1024`。
+
+## 结果契约
+
+每行任务对应：
+
+```text
+results/samples/<dataset>/<model>/steps_<N>/samples.jsonl
+results/samples/<dataset>/<model>/steps_<N>/run_metadata.json
+results/metrics/<dataset>/<model>/steps_<N>/metrics.json
+results/timing/<dataset>/<model>/steps_<N>/timing.json
+```
+
+正式任务必须 `sample_count=1024`、`seed=42`，并通过 source/config/checkpoint/adapter/environment provenance 审计。质量指标使用 GPT-2 Large Generative PPL、平均 per-sample unigram entropy、Self-BLEU；延迟使用独立 timing 的 `seconds_per_sample`。
+
+## 可执行矩阵文件
+
+```bash
+python -m dlb.matrix --root "$DLB_ROOT" \
+  --output "$DLB_ROOT/results/matrix/generation.tsv"
+```
+
+TSV 第一行是 `# schema=dlb-generation-matrix-v1`，第二行是固定字段名。解析使用 CSV/TSV reader，不使用 `eval`。不要手动重排或编辑任务行；如果 registry 改动，重新生成并审阅 unsupported inventory。

docs/superpowers/plans/2026-08-25-conditional-generation.md

@@ -0,0 +1,1116 @@
+# Zero-Shot Conditional Generation Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a zero-training `c64_zs_v1` benchmark that evaluates every existing unconditional checkpoint with an immutable 64-token real prefix and a generated continuation.
+
+**Architecture:** Extend the shared request and adapter boundaries with an explicit conditional mode while keeping unconditional identities and artifacts backward-compatible. Conditional prompts, samples, matrix, metrics, timing, aggregation, and scripts use separate versioned contracts and `results/conditional/` paths; native sampler projection APIs are used when available, with scoped adapter-level runtime clamps for other families.
+
+**Tech Stack:** Python 3.11, Pydantic 2, PyYAML, Hugging Face Datasets/Transformers, PyTorch, MAUVE 0.3.0, pytest 8, Bash, existing pinned model-specific Conda environments.
+
+**Spec:** `docs/superpowers/specs/2026-08-25-conditional-generation-design.md`
+
+## Global Constraints
+
+- Protocol identifier is exactly `c64_zs_v1`; configuration schema version is `1`.
+- Reuse existing checkpoints only: no training, fine-tuning, checkpoint rewriting, or upstream repository edits.
+- Use selection seed `42`, sampling seed `42`, exactly `1,024` prompts, prefix length `64`, and aligned evaluation-continuation length `64`.
+- Produce completion `0` for prompt IDs `0..1023` and completions `1..4` for prompt IDs `0..255`, exactly `2,048` records per supported step task.
+- LM1B uses the existing BERT 128-token processed validation split; OWT uses the existing GPT-2 1,024-token processed validation split.
+- OWT generation retains the full 960-token suffix; aligned quality metrics use only its first 64 suffix tokens.
+- The first 64 output tokens must equal the prompt prefix after every relevant sampler transition and in every published record; any mismatch invalidates the artifact.
+- The conditional matrix contains the same 132 supported step tasks as the unconditional matrix, with RDLM/OWT retained in a separate unsupported inventory.
+- Conditional outputs live below `results/conditional/`; unconditional result paths and successful-publication identity semantics remain unchanged.
+- All model/tokenizer/checkpoint/prompt/sample artifacts are local-only and SHA-256 bound; no runtime network fallback is allowed.
+- Artifact writes are atomic and fail closed; batch-size incompatibility, partial schedules, duplicate IDs, digest drift, and token-bound violations are errors.
+- Preserve unrelated working-tree changes, including user-owned untracked diagnostics files.
+
+## File and responsibility map
+
+**Protocol and prompt artifacts**
+
+- Create `configs/conditional.yaml`: canonical experiment constants.
+- Create `src/dlb/conditional_prompts.py`: typed protocol/prompt contracts, deterministic selection, prompt build/verify logic.
+- Create `scripts/build_conditional_prompts.py` and `scripts/verify_conditional_prompts.py`: thin CLIs.
+
+**Sample and execution contracts**
+
+- Modify `src/dlb/schema.py`: add `ConditionalSampleRecord` without changing `SampleRecord`.
+- Modify `src/dlb/io.py`: conditional JSONL reader/validator/atomic writer.
+- Modify `src/dlb/runner.py`: conditional request identity, validation, publication branch, and CLI flags.
+- Create `src/dlb/conditional_matrix.py`: separate versioned 132-task matrix and unsupported inventory.
+
+**Conditioning runtime**
+
+- Create `src/dlb/adapters/conditional_runtime.py`: prompt batching, token/one-hot/embedding clamps, scoped monkey-patch restoration, native projection builders.
+- Modify `src/dlb/adapters/base.py`, `src/dlb/adapters/capture.py`, and all files in `src/dlb/adapters/{flm,mdlm,duo,candi,langflow,rdlm,sdtt,di4c}.py`: serialize and consume conditional arguments.
+- Modify `adapters/_distilled_runtime.py`, `adapters/sample_sdtt.py`, `adapters/sample_di4c.py`, and `adapters/sample_langflow.py`: server-backed prompt loading, projection, capture, and timing.
+
+**Evaluation and reporting**
+
+- Create `evaluation/conditional_perplexity.py`: suffix-only causal loss masking.
+- Create `evaluation/mauve_score.py`: pinned local-only MAUVE wrapper.
+- Create `evaluation/conditional_evaluate.py`: exact schedule validation and all conditional metrics.
+- Modify `evaluation/self_bleu.py` and `evaluation/unigram_entropy.py`: token-row/group APIs reusable by both protocols.
+- Create `src/dlb/conditional_benchmarking.py`: conditional latency command and provenance publication.
+- Create `src/dlb/conditional_aggregate.py`: strict conditional result validation and summary publication.
+
+**Launch and verification**
+
+- Create conditional one/all/four-GPU generation, evaluation, timing, smoke, and aggregate scripts under `scripts/`.
+- Modify `src/dlb/gpu_matrix.py`: accept an explicit conditional protocol and route to conditional scripts without altering default routing.
+- Modify `README.md` and the relevant experiment documentation with server commands and zero-shot/OOD interpretation.
+
+---
+
+### Task 1: Canonical protocol and deterministic prompt artifacts
+
+**Files:**
+
+- Create: `configs/conditional.yaml`
+- Create: `src/dlb/conditional_prompts.py`
+- Create: `scripts/build_conditional_prompts.py`
+- Create: `scripts/verify_conditional_prompts.py`
+- Test: `tests/test_conditional_prompts.py`
+
+**Interfaces:**
+
+- Consumes: `artifacts/data.yaml`, `data/manifests/{lm1b,owt}.json`, and processed validation rows containing `input_ids`.
+- Produces: `ConditionalProtocol`, `PromptRecord`, `PromptManifest`, `load_protocol(path)`, `select_source_indices(row_count, count, seed)`, `build_prompts(root, dataset_id, protocol)`, and `verify_prompts(root, dataset_id, protocol) -> PromptManifest`.
+
+- [ ] **Step 1: Write failing protocol and selection tests**
+
+```python
+def test_protocol_has_exact_c64_production_contract(tmp_path):
+    path = tmp_path / "conditional.yaml"
+    path.write_text(PRODUCTION_CONFIG, encoding="utf-8")
+    protocol = load_protocol(path)
+    assert protocol.protocol == "c64_zs_v1"
+    assert (protocol.prompt_count, protocol.prefix_length) == (1024, 64)
+    assert protocol.datasets["owt"].model_length == 1024
+
+
+def test_selection_is_unique_stable_and_seed_bound():
+    first = select_source_indices(4096, 1024, 42)
+    assert first == select_source_indices(4096, 1024, 42)
+    assert first != select_source_indices(4096, 1024, 43)
+    assert len(first) == len(set(first)) == 1024
+```
+
+- [ ] **Step 2: Run tests and confirm missing-module failure**
+
+Run: `pytest tests/test_conditional_prompts.py -q`
+
+Expected: collection fails because `dlb.conditional_prompts` does not exist.
+
+- [ ] **Step 3: Implement the typed protocol, SHA-256 ordering, and prompt records**
+
+```python
+class ConditionalProtocol(StrictModel):
+    schema_version: Literal[1]
+    protocol: Literal["c64_zs_v1"]
+    selection_seed: StrictInt
+    sampling_seed: StrictInt
+    prompt_count: Literal[1024]
+    prefix_length: Literal[64]
+    evaluation_continuation_length: Literal[64]
+    diversity_prompt_count: Literal[256]
+    completions_per_diversity_prompt: Literal[5]
+    datasets: dict[str, ConditionalDataset]
+
+
+def select_source_indices(row_count: int, count: int, seed: int) -> list[int]:
+    if row_count < count or count <= 0:
+        raise ValueError("processed validation split has too few rows")
+    return sorted(
+        range(row_count),
+        key=lambda index: hashlib.sha256(f"{seed}:{index}".encode()).digest(),
+    )[:count]
+```
+
+`build_prompts` must load `data/processed/<dataset-contract>/validation` with `datasets.load_from_disk`, preserve selected order as `prompt_id`, slice exactly `[0:64]` and `[64:128]`, validate against the dataset vocabulary size, write deterministic compact JSONL through the safe atomic writer, and publish a manifest that binds source manifest SHA, tokenizer ID/revision, selection algorithm, seed, counts, lengths, and prompt-file SHA.
+
+- [ ] **Step 4: Add tamper, token-bound, and CLI tests, then make them pass**
+
+```python
+def test_verify_rejects_prompt_file_tampering(built_prompt_tree):
+    prompts = built_prompt_tree / "data/conditional/lm1b-c64/prompts.jsonl"
+    prompts.write_bytes(prompts.read_bytes() + b"\n")
+    with pytest.raises(ValueError, match="prompt file SHA-256"):
+        verify_prompts(built_prompt_tree, "lm1b", production_protocol())
+
+
+def test_prompt_cli_uses_processed_validation_without_repacking(monkeypatch, tmp_path):
+    observed = install_fake_load_from_disk(monkeypatch, rows=2048)
+    assert build_main(["--root", str(tmp_path), "--dataset", "lm1b"]) == 0
+    assert observed == [tmp_path / "data/processed/lm1b-bert-128/validation"]
+```
+
+Run: `pytest tests/test_conditional_prompts.py -q`
+
+Expected: all tests pass.
+
+- [ ] **Step 5: Commit protocol and prompt artifacts**
+
+```bash
+git add configs/conditional.yaml src/dlb/conditional_prompts.py \
+  scripts/build_conditional_prompts.py scripts/verify_conditional_prompts.py \
+  tests/test_conditional_prompts.py
+git commit -m "feat: add deterministic conditional prompt manifests"
+```
+
+### Task 2: Conditional sample schema and atomic I/O
+
+**Files:**
+
+- Modify: `src/dlb/schema.py`
+- Modify: `src/dlb/io.py`
+- Create: `tests/test_conditional_schema.py`
+- Create: `tests/test_conditional_io.py`
+
+**Interfaces:**
+
+- Consumes: `PromptRecord` and protocol lengths from Task 1.
+- Produces: `ConditionalSampleRecord`, `expected_conditional_schedule(prompt_count=1024, diversity_prompt_count=256, completions=5) -> Sequence[tuple[int, int]]`, `read_conditional_samples(path)`, `validate_conditional_samples(path, expected=2048, schedule=production_schedule, sequence_length=model_length, vocab_size=dataset_vocab_size)`, and `write_conditional_samples_atomic(path, records, expected=2048, schedule=production_schedule, sequence_length=model_length, vocab_size=dataset_vocab_size)`.
+
+- [ ] **Step 1: Write failing schema-invariant tests**
+
+```python
+def test_conditional_record_binds_prefix_full_and_suffix_slices():
+    record = ConditionalSampleRecord.model_validate(valid_conditional_record())
+    assert record.full_token_ids[:64] == record.prefix_token_ids
+    assert record.full_token_ids[64:] == record.continuation_token_ids
+    assert record.prefix_exact_match is True
+
+
+@pytest.mark.parametrize("mutation,message", [
+    (lambda value: value.update(prefix_exact_match=False), "prefix_exact_match"),
+    (lambda value: value["full_token_ids"].__setitem__(0, 999), "prefix"),
+    (lambda value: value.update(reference_token_ids=[1] * 63), "64"),
+])
+def test_conditional_record_rejects_invalid_publication(mutation, message):
+    value = valid_conditional_record()
+    mutation(value)
+    with pytest.raises(ValidationError, match=message):
+        ConditionalSampleRecord.model_validate(value)
+```
+
+- [ ] **Step 2: Run the schema tests and verify they fail**
+
+Run: `pytest tests/test_conditional_schema.py -q`
+
+Expected: import fails because `ConditionalSampleRecord` is absent.
+
+- [ ] **Step 3: Implement the separate record and canonical schedule**
+
+```python
+NonNegativeToken = Annotated[StrictInt, Field(ge=0)]
+
+
+class ConditionalSampleRecord(StrictModel):
+    sample_id: StrictInt = Field(ge=0)
+    prompt_id: StrictInt = Field(ge=0, le=1023)
+    completion_id: StrictInt = Field(ge=0, le=4)
+    source_index: StrictInt = Field(ge=0)
+    prefix_token_ids: list[NonNegativeToken]
+    continuation_token_ids: list[NonNegativeToken] = Field(min_length=1)
+    reference_token_ids: list[NonNegativeToken]
+    full_token_ids: list[NonNegativeToken] = Field(min_length=65)
+    prefix_text: str
+    continuation_text: str
+    reference_text: str
+    full_text: str
+    seed: StrictInt
+    generation_seconds: Annotated[FiniteFloat, Field(ge=0)]
+    prefix_exact_match: Literal[True]
+
+    @model_validator(mode="after")
+    def validate_slices(self):
+        if len(self.prefix_token_ids) != 64 or len(self.reference_token_ids) != 64:
+            raise ValueError("prefix and reference must each contain 64 tokens")
+        if self.full_token_ids[:64] != self.prefix_token_ids:
+            raise ValueError("full token prefix differs from fixed prefix")
+        if self.full_token_ids[64:] != self.continuation_token_ids:
+            raise ValueError("continuation differs from full token suffix")
+        return self
+
+
+def expected_conditional_schedule(
+    prompt_count: int = 1024,
+    diversity_prompt_count: int = 256,
+    completions: int = 5,
+) -> list[tuple[int, int]]:
+    return [(prompt, 0) for prompt in range(prompt_count)] + [
+        (prompt, completion)
+        for completion in range(1, completions)
+        for prompt in range(diversity_prompt_count)
+    ]
+```
+
+- [ ] **Step 4: Implement streaming conditional I/O and verify exact schedule**
+
+The conditional validator must parse JSON with duplicate-key rejection, require `sample_id == line index`, require `(prompt_id, completion_id)` to equal the same index in `expected_conditional_schedule()`, require the dataset model length (128 for LM1B or 1,024 for OWT), validate token bounds against the supplied `vocab_size`, and never call or weaken `validate_samples`.
+
+```python
+def test_writer_rejects_duplicate_schedule_entry_without_replacing_final(tmp_path):
+    final = tmp_path / "samples.jsonl"
+    final.write_text("old\n", encoding="utf-8")
+    records = production_records()
+    records[1024]["prompt_id"] = 1
+    with pytest.raises(SampleValidationError, match="expected prompt/completion"):
+        write_conditional_samples_atomic(final, records, expected=2048)
+    assert final.read_text(encoding="utf-8") == "old\n"
+```
+
+Run: `pytest tests/test_conditional_schema.py tests/test_conditional_io.py tests/test_schema.py tests/test_io.py -q`
+
+Expected: all conditional and unconditional schema/I/O tests pass.
+
+- [ ] **Step 5: Commit the artifact contract**
+
+```bash
+git add src/dlb/schema.py src/dlb/io.py \
+  tests/test_conditional_schema.py tests/test_conditional_io.py
+git commit -m "feat: add conditional sample artifact contract"
+```
+
+### Task 3: Conditional matrix and shared runner mode
+
+**Files:**
+
+- Create: `src/dlb/conditional_matrix.py`
+- Modify: `src/dlb/runner.py`
+- Create: `tests/test_conditional_matrix.py`
+- Create: `tests/test_conditional_runner.py`
+
+**Interfaces:**
+
+- Consumes: `ConditionalProtocol`, verified prompt manifests, conditional I/O, existing registry/checkpoint provenance, and existing `SampleAdapter`.
+- Produces: `ConditionalMatrixTask`, `build_conditional_matrix(registry, root=None, protocol=None) -> list[ConditionalMatrixTask]`, schema `dlb-conditional-generation-matrix-v1`, and conditional `RunRequest` fields passed unchanged to adapters.
+
+- [ ] **Step 1: Write failing matrix parity and path-isolation tests**
+
+```python
+def test_conditional_matrix_matches_supported_unconditional_tasks(registry, tmp_path):
+    ordinary = build_matrix(registry, root=tmp_path)
+    conditional = build_conditional_matrix(registry, root=tmp_path)
+    assert len(conditional) == len(ordinary) == 132
+    assert [(t.model, t.dataset, t.steps) for t in conditional] == [
+        (t.model, t.dataset, t.steps) for t in ordinary
+    ]
+    assert all("/results/conditional/" in task.sample_dir for task in conditional)
+    assert all(task.sample_count == 2048 for task in conditional)
+
+
+def test_conditional_unsupported_inventory_is_rdlm_owt(registry):
+    assert conditional_unsupported_inventory(registry) == [{
+        "status": "unsupported", "model": "rdlm", "dataset": "owt",
+        "category": "few", "reason": registry.models["rdlm"].datasets["owt"].reason,
+    }]
+```
+
+- [ ] **Step 2: Write failing request identity and publication tests**
+
+```python
+def test_unconditional_identity_has_no_conditional_keys(base_request):
+    identity = _identity(base_request, ["python", "sample.py"])
+    assert "generation_mode" not in identity
+    assert "conditioning_manifest_sha256" not in identity
+
+
+def test_conditional_identity_binds_manifest_and_schedule(conditional_request):
+    identity = _identity(conditional_request, ["python", "sample.py"])
+    assert identity["generation_mode"] == "conditional_prefix"
+    assert identity["conditioning_manifest_sha256"] == "a" * 64
+    assert identity["prefix_length"] == 64
+    assert identity["completion_schedule"] == "c0:p0-1023;c1-4:p0-255"
+```
+
+- [ ] **Step 3: Implement the separate matrix**
+
+```python
+CONDITIONAL_MATRIX_SCHEMA = "dlb-conditional-generation-matrix-v1"
+
+@dataclass(frozen=True)
+class ConditionalMatrixTask:
+    task_id: str
+    category: str
+    model: str
+    dataset: str
+    steps: int
+    sample_count: Literal[2048]
+    seed: int
+    environment: str
+    adapter: str
+    source: str
+    provenance: str
+    protocol: Literal["c64_zs_v1"]
+    conditioning_manifest: str
+    conditioning_manifest_sha256: str
+    sample_dir: str
+    metrics_path: str
+    timing_path: str
+```
+
+Derive model/dataset/step ordering from `build_matrix`, replace only protocol-specific columns and paths, validate the two prompt manifests first, and reuse the existing unsupported inventory writer with a conditional schema header.
+
+- [ ] **Step 4: Extend `RunRequest` and branch publication without changing unconditional behavior**
+
+```python
+@dataclass(frozen=True)
+class RunRequest:
+    # existing fields remain in their current order
+    generation_mode: Literal["unconditional", "conditional_prefix"] = "unconditional"
+    conditioning_manifest: str | None = None
+    conditioning_manifest_sha256: str | None = None
+    conditioning_config_sha256: str | None = None
+    prefix_length: int | None = None
+    evaluation_continuation_length: int | None = None
+    prompt_count: int | None = None
+    diversity_prompt_count: int | None = None
+    completions_per_diversity_prompt: int | None = None
+    completion_schedule: str | None = None
+```
+
+`_resolve_request` must call `verify_prompts` for conditional requests and reject conditional fields on unconditional requests. `_identity` must add conditional keys only when `generation_mode == "conditional_prefix"`. `run_experiment` selects `validate_samples`/`write_samples_atomic` for unconditional mode and `validate_conditional_samples`/`write_conditional_samples_atomic` for conditional mode. Add matching CLI flags including `--generation-mode`, `--conditioning-manifest`, and `--conditioning-config`.
+
+Run: `pytest tests/test_conditional_matrix.py tests/test_conditional_runner.py tests/test_matrix.py tests/test_runner.py -q`
+
+Expected: all tests pass and the old runner fixtures produce byte-for-byte equivalent unconditional identity dictionaries.
+
+- [ ] **Step 5: Commit runner and matrix support**
+
+```bash
+git add src/dlb/conditional_matrix.py src/dlb/runner.py \
+  tests/test_conditional_matrix.py tests/test_conditional_runner.py
+git commit -m "feat: add conditional matrix and runner mode"
+```
+
+### Task 4: Shared hard-prefix runtime primitives
+
+**Files:**
+
+- Create: `src/dlb/adapters/conditional_runtime.py`
+- Create: `tests/test_conditional_runtime.py`
+
+**Interfaces:**
+
+- Consumes: verified `PromptRecord` rows and tensors produced by model-specific samplers.
+- Produces: `ConditioningBatch`, `load_conditioning_batch(manifest_path, expected_manifest_sha256, completion_id, prompt_start, batch_size, device, vocab_size) -> ConditioningBatch`, `clamp_token_prefix(state, prefix_ids)`, `clamp_vocab_prefix(state, prefix_ids)`, `clamp_embedding_prefix(state, clean_embeddings)`, `token_project_fn(prefix_ids)`, `vocab_project_fn(prefix_ids)`, `embedding_project_fn(clean_embeddings)`, and `patched_attribute(owner, name, replacement)`.
+
+- [ ] **Step 1: Write failing clamp and restoration tests**
+
+```python
+def test_token_projector_clamps_every_call():
+    prefix = torch.tensor([[4, 5], [6, 7]])
+    project = token_project_fn(prefix)
+    state = torch.tensor([[99, 99, 8], [99, 99, 9]])
+    assert project(state).tolist() == [[4, 5, 8], [6, 7, 9]]
+    state[:, :2] = 88
+    assert project(state).tolist() == [[4, 5, 8], [6, 7, 9]]
+
+
+def test_scoped_patch_restores_even_after_sampler_error():
+    owner = FakeOwner()
+    original = owner.update
+    with pytest.raises(RuntimeError):
+        with patched_attribute(owner, "update", lambda *_: (_ for _ in ()).throw(RuntimeError())):
+            owner.update(None)
+    assert owner.update.__func__ is original.__func__
+```
+
+- [ ] **Step 2: Run tests and verify the runtime module is missing**
+
+Run: `pytest tests/test_conditional_runtime.py -q`
+
+Expected: import failure for `dlb.adapters.conditional_runtime`.
+
+- [ ] **Step 3: Implement shape-safe token, vocabulary, and embedding projection**
+
+```python
+@dataclass(frozen=True)
+class ConditioningBatch:
+    prompt_ids: Sequence[int]
+    source_indices: Sequence[int]
+    prefix_token_ids: object
+    reference_token_ids: object
+
+
+def clamp_token_prefix(state, prefix_ids):
+    if state.ndim != 2 or prefix_ids.ndim != 2:
+        raise ValueError("token state and prefix must be rank two")
+    if state.shape[0] != prefix_ids.shape[0] or state.shape[1] < prefix_ids.shape[1]:
+        raise ValueError("token state is incompatible with prefix batch")
+    result = state.clone()
+    result[:, : prefix_ids.shape[1]] = prefix_ids.to(device=state.device, dtype=state.dtype)
+    return result
+
+
+def clamp_vocab_prefix(state, prefix_ids):
+    clean = torch.nn.functional.one_hot(prefix_ids, num_classes=state.shape[-1]).to(state)
+    result = state.clone()
+    result[:, : prefix_ids.shape[1], :] = clean
+    return result
+
+
+def clamp_embedding_prefix(state, clean_embeddings):
+    result = state.clone()
+    result[:, : clean_embeddings.shape[1], :] = clean_embeddings.to(state)
+    return result
+```
+
+All functions must reject device/batch/sequence/vocabulary mismatches, preserve suffix bytes, and avoid in-place mutation of caller-owned tensors. Projector closures expose `conditioning_implementation` metadata and are safe for repeated calls.
+
+- [ ] **Step 4: Add exact prompt-batch schedule tests and pass them**
+
+`load_conditioning_batch` accepts a prompt JSONL path, `completion_id`, `start_prompt`, `batch_size`, device, and tokenizer vocabulary. It rejects completion 0 beyond prompt 1023, completions 1–4 beyond prompt 255, and any batch that crosses its schedule boundary.
+
+Run: `pytest tests/test_conditional_runtime.py -q`
+
+Expected: token, vocabulary, embedding, schedule, and restoration cases pass.
+
+- [ ] **Step 5: Commit runtime primitives**
+
+```bash
+git add src/dlb/adapters/conditional_runtime.py tests/test_conditional_runtime.py
+git commit -m "feat: add hard-prefix conditioning runtime"
+```
+
+### Task 5: Teacher-family adapters for MDLM, Duo, FLM/FMLM, and CANDI
+
+**Files:**
+
+- Modify: `src/dlb/adapters/base.py`
+- Modify: `src/dlb/adapters/capture.py`
+- Modify: `src/dlb/adapters/mdlm.py`
+- Modify: `src/dlb/adapters/duo.py`
+- Modify: `src/dlb/adapters/flm.py`
+- Modify: `src/dlb/adapters/candi.py`
+- Create: `tests/test_conditional_teacher_adapters.py`
+- Modify: `tests/test_capture.py`
+
+**Interfaces:**
+
+- Consumes: conditional request fields and runtime projectors from Tasks 3–4.
+- Produces: uniform capture flags, `install_teacher_conditioning(owner, family, batch, tokenizer)`, and conditional capture records containing prompt/source/completion identity plus full generated token IDs.
+
+- [ ] **Step 1: Write failing command serialization tests for every teacher family**
+
+```python
+@pytest.mark.parametrize("model", ["flm", "fmlm", "duo", "duo-dcd", "mdlm", "candi"])
+def test_teacher_command_serializes_complete_conditioning_contract(model, conditional_request, adapter_for):
+    command = adapter_for(model).build_command(conditional_request(model), RUN_DIR)
+    assert option(command, "--generation-mode") == "conditional_prefix"
+    assert option(command, "--conditioning-manifest") == conditional_request(model).conditioning_manifest
+    assert option(command, "--prefix-length") == "64"
+    assert option(command, "--completion-schedule") == "c0:p0-1023;c1-4:p0-255"
+```
+
+- [ ] **Step 2: Write fake-sampler tests that observe the prefix at every update**
+
+```python
+def test_mdlm_prior_and_every_ancestral_state_keep_real_prefix(fake_mdlm, batch):
+    with install_teacher_conditioning(fake_mdlm, "mdlm", batch, fake_tokenizer):
+        output = fake_mdlm.sample()
+    assert fake_mdlm.observed_prefixes == [batch.prefix.tolist()] * fake_mdlm.step_count
+    assert output[:, :64].tolist() == batch.prefix.tolist()
+
+
+def test_duo_clamps_before_and_after_every_ancestral_update(fake_duo, batch):
+    with install_teacher_conditioning(fake_duo, "duo", batch, fake_tokenizer):
+        output = fake_duo.sample()
+    assert all(prefix == batch.prefix.tolist() for prefix in fake_duo.before_update)
+    assert all(prefix == batch.prefix.tolist() for prefix in fake_duo.after_update)
+
+
+def test_flm_forward_always_receives_clean_prefix_one_hot(fake_flm, batch):
+    with install_teacher_conditioning(fake_flm, "flm", batch, fake_tokenizer):
+        fake_flm.sample()
+    assert all(torch.equal(value, batch.clean_one_hot) for value in fake_flm.forward_prefixes)
+```
+
+- [ ] **Step 3: Extend the capture invocation and adapter output conversion**
+
+Add these exact capture-only arguments: `--generation-mode`, `--conditioning-manifest`, `--conditioning-manifest-sha256`, `--prefix-length`, `--prompt-count`, `--diversity-prompt-count`, `--completions-per-diversity-prompt`, and `--completion-schedule`. In conditional mode, `_capture_teacher` iterates the canonical schedule without ceiling batches and emits one raw capture item per scheduled prompt/completion pair with `prompt_id`, `completion_id`, `source_index`, `prefix_token_ids`, `reference_token_ids`, `full_token_ids`, and batch elapsed time divided by the exact batch size.
+
+`BaseTeacherAdapter.convert_outputs` must branch to a `_convert_conditional_capture_outputs` method that decodes prefix/reference/full/continuation separately with the locked canonical tokenizer and constructs `ConditionalSampleRecord`; its unconditional branch remains unchanged.
+
+- [ ] **Step 4: Implement family-specific hard conditioning**
+
+```python
+if family == "mdlm":
+    patch_prior_to_insert_clean_prefix(owner, batch.prefix_token_ids)
+    patch_ancestral_update_with_token_pre_post_clamp(owner, batch.prefix_token_ids)
+elif family == "duo":
+    patch_ancestral_update_with_token_pre_post_clamp(owner, batch.prefix_token_ids)
+elif family in {"flm", "fmlm"}:
+    patch_forward_with_vocab_prefix(owner, batch.prefix_token_ids)
+elif family == "candi":
+    kwargs["prompt_tokens"] = batch.prefix_token_ids
+    kwargs["prompt_mask"] = torch.ones_like(batch.prefix_token_ids, dtype=torch.bool)
+```
+
+All paths perform a final token clamp plus exact assertion. Metadata is `native_projection` for CANDI and `zero_shot_runtime_projection` for MDLM/Duo/FLM/FMLM. FMLM metadata also contains `paper_conditional_training_reproduced: false`.
+
+Run: `pytest tests/test_conditional_teacher_adapters.py tests/test_capture.py tests/test_teacher_adapters.py -q`
+
+Expected: conditional tests pass and all existing teacher/capture tests remain green.
+
+- [ ] **Step 5: Commit teacher-family integration**
+
+```bash
+git add src/dlb/adapters/base.py src/dlb/adapters/capture.py \
+  src/dlb/adapters/mdlm.py src/dlb/adapters/duo.py \
+  src/dlb/adapters/flm.py src/dlb/adapters/candi.py \
+  tests/test_conditional_teacher_adapters.py tests/test_capture.py
+git commit -m "feat: condition teacher-family samplers on fixed prefixes"
+```
+
+### Task 6: Native projected SDTT and Di4C samplers
+
+**Files:**
+
+- Modify: `src/dlb/adapters/sdtt.py`
+- Modify: `src/dlb/adapters/di4c.py`
+- Modify: `adapters/_distilled_runtime.py`
+- Modify: `adapters/sample_sdtt.py`
+- Modify: `adapters/sample_di4c.py`
+- Create: `tests/test_conditional_distilled_adapters.py`
+
+**Interfaces:**
+
+- Consumes: conditional request/capture contract and `token_project_fn`/`vocab_project_fn`.
+- Produces: native `project_fn` wiring for SDTT and Di4C, exact conditional capture JSON, and benchmark callbacks that include projection time.
+
+- [ ] **Step 1: Write failing SDTT/Di4C CLI and native-projection tests**
+
+```python
+@pytest.mark.parametrize("model", ["mdlm-sdtt", "duo-di4c", "mdlm-di4c"])
+def test_distilled_command_passes_manifest_sha_and_schedule(model, request, adapter_for):
+    command = adapter_for(model).build_command(request(model), RUN_DIR)
+    assert option(command, "--conditioning-manifest-sha256") == "a" * 64
+    assert option(command, "--completion-schedule") == "c0:p0-1023;c1-4:p0-255"
+
+
+def test_sdtt_native_project_fn_is_called_at_every_step(fake_sdtt_runtime, prefix):
+    result = fake_sdtt_runtime.sample_with_prefix(prefix, steps=7)
+    assert fake_sdtt_runtime.project_calls == 7
+    assert torch.equal(result[:, :64], prefix)
+```
+
+- [ ] **Step 2: Run focused tests and confirm missing flags/projection failures**
+
+Run: `pytest tests/test_conditional_distilled_adapters.py -q`
+
+Expected: assertions fail because current wrappers have no conditional arguments.
+
+- [ ] **Step 3: Add authenticated prompt loading to the server runtime**
+
+`adapters/_distilled_runtime.py` must verify prompt-file and manifest SHA-256 before model materialization, validate tokenizer ID/revision and vocabulary bounds, materialize only the exact prompt batch, and expose:
+
+```python
+def load_conditional_batch(
+    manifest_path: Path,
+    expected_manifest_sha256: str,
+    *,
+    completion_id: int,
+    prompt_start: int,
+    prompt_count: int,
+    device: str,
+    vocab_size: int,
+) -> ConditioningBatch:
+    return load_conditioning_batch(
+        manifest_path,
+        expected_manifest_sha256,
+        completion_id=completion_id,
+        prompt_start=prompt_start,
+        batch_size=prompt_count,
+        device=device,
+        vocab_size=vocab_size,
+    )
+```
+
+- [ ] **Step 4: Pass native `project_fn` throughout both sampler entrypoints**
+
+For masked states, the native projection writes prefix token IDs into the discrete state. For categorical/one-hot states, it writes the clean prefix one-hot endpoint. Pass the closure to the pinned upstream sampler's existing `project_fn` parameter for every reverse step, assert the result prefix, and write conditional capture fields in canonical schedule order. `benchmark_model` must time the same closure inside the measured generation callback.
+
+Run: `pytest tests/test_conditional_distilled_adapters.py tests/test_distilled_adapters.py tests/test_timing.py -q`
+
+Expected: new and existing distilled adapter tests pass.
+
+- [ ] **Step 5: Commit native distilled projections**
+
+```bash
+git add src/dlb/adapters/sdtt.py src/dlb/adapters/di4c.py \
+  adapters/_distilled_runtime.py adapters/sample_sdtt.py adapters/sample_di4c.py \
+  tests/test_conditional_distilled_adapters.py
+git commit -m "feat: add native prefix projection to distilled samplers"
+```
+
+### Task 7: LangFlow embedding projection and RDLM manifold projection
+
+**Files:**
+
+- Modify: `src/dlb/adapters/langflow.py`
+- Modify: `src/dlb/adapters/rdlm.py`
+- Modify: `src/dlb/adapters/capture.py`
+- Modify: `adapters/sample_langflow.py`
+- Create: `tests/test_conditional_continuous_adapters.py`
+
+**Interfaces:**
+
+- Consumes: `embedding_project_fn`, `vocab_project_fn`, conditional request fields, and canonical prompt batches.
+- Produces: `install_langflow_conditioning(model, batch, tokenizer)` and `run_rdlm_conditional(model, batch, tokenizer, sampling_config)`, both with final token exact-match assertions.
+
+- [ ] **Step 1: Write failing continuous-state observation tests**
+
+```python
+def test_langflow_clamps_noisy_and_self_conditioning_before_every_forward(fake_langflow, batch):
+    with install_langflow_conditioning(fake_langflow, batch):
+        output = fake_langflow.generate()
+    assert len(fake_langflow.noisy_prefixes) == fake_langflow.step_count
+    assert all(torch.equal(x, batch.clean_embeddings) for x in fake_langflow.noisy_prefixes)
+    assert all(torch.equal(x, batch.clean_embeddings) for x in fake_langflow.self_cond_prefixes)
+    assert torch.equal(output[:, :64], batch.prefix_token_ids)
+
+
+def test_rdlm_passes_clean_manifold_projection_to_sampling_factory(fake_rdlm, batch):
+    output = run_rdlm_conditional(fake_rdlm, batch)
+    assert fake_rdlm.proj_fn is not None
+    assert fake_rdlm.proj_calls == fake_rdlm.step_count
+    assert torch.equal(output[:, :64], batch.prefix_token_ids)
+```
+
+- [ ] **Step 2: Run focused tests and verify current adapters fail**
+
+Run: `pytest tests/test_conditional_continuous_adapters.py -q`
+
+Expected: failures show no LangFlow conditioning hook and no RDLM projection.
+
+- [ ] **Step 3: Implement LangFlow clean-embedding projection**
+
+Before each LangFlow forward evaluation, derive clean prefix embeddings from the loaded model embedding table and replace positions `:64` in both `noisy_embeds` and non-null `x_self_cond`. The suffix tensor must be byte-identical before/after the hook. Restore the original forward method after sampling and record `conditioning_implementation: zero_shot_runtime_projection` and `paper_conditional_training_reproduced: false`.
+
+- [ ] **Step 4: Implement RDLM native manifold projection**
+
+Construct the clean one-hot prefix endpoint in RDLM's vocabulary/manifold coordinates and pass `proj_fn=project` to the pinned `get_sampling_fn` call. The closure clamps every call, preserves suffix coordinates, and the decoded output receives a final token-level assertion. Record `conditioning_implementation: native_projection`.
+
+Run: `pytest tests/test_conditional_continuous_adapters.py tests/test_continuous_adapters.py tests/test_capture.py -q`
+
+Expected: all continuous, capture, LangFlow, and RDLM tests pass.
+
+- [ ] **Step 5: Commit continuous/manifold integration**
+
+```bash
+git add src/dlb/adapters/langflow.py src/dlb/adapters/rdlm.py \
+  src/dlb/adapters/capture.py adapters/sample_langflow.py \
+  tests/test_conditional_continuous_adapters.py
+git commit -m "feat: condition flow and manifold samplers on prefixes"
+```
+
+### Task 8: Conditional quality and diversity evaluation
+
+**Files:**
+
+- Create: `evaluation/conditional_perplexity.py`
+- Create: `evaluation/mauve_score.py`
+- Create: `evaluation/conditional_evaluate.py`
+- Modify: `evaluation/self_bleu.py`
+- Modify: `evaluation/unigram_entropy.py`
+- Create: `tests/test_conditional_perplexity.py`
+- Create: `tests/test_mauve_score.py`
+- Create: `tests/test_conditional_evaluate.py`
+
+**Interfaces:**
+
+- Consumes: 2,048 validated `ConditionalSampleRecord` objects and pinned local GPT-2-large assets.
+- Produces: `compute_conditional_ppl(prefixes, continuations, model, tokenizer, batch_size=8)`, `compute_mauve_score(generated, references, assets, device_id)`, `compute_grouped_self_bleu(token_rows_by_prompt)`, `conditional_entropy(records, slice_length=64)`, and schema `dlb-conditional-metrics-v1`.
+
+- [ ] **Step 1: Write failing suffix-only causal-loss tests**
+
+```python
+def test_conditional_ppl_masks_prefix_targets_and_counts_suffix_only(fake_scorer, tokenizer):
+    result = compute_conditional_ppl(
+        prefixes=["alpha beta"], continuations=["gamma delta"],
+        model=fake_scorer, tokenizer=tokenizer, batch_size=1,
+    )
+    assert fake_scorer.target_masks == [[0, 0, 1, 1]]
+    assert result.valid_token_count == 2
+
+
+def test_conditional_ppl_tokenizes_prefix_and_suffix_separately(spy_tokenizer, fake_scorer):
+    compute_conditional_ppl(["prefix"], [" suffix"], fake_scorer, spy_tokenizer)
+    assert spy_tokenizer.calls == [(["prefix"], False), ([" suffix"], False)]
+```
+
+- [ ] **Step 2: Implement target-mask scoring**
+
+```python
+def compute_conditional_ppl(prefixes, continuations, model, tokenizer, *, batch_size=8):
+    prefix_rows = tokenize_without_special_tokens(tokenizer, prefixes)
+    suffix_rows = tokenize_without_special_tokens(tokenizer, continuations)
+    input_rows = [prefix + suffix for prefix, suffix in zip(prefix_rows, suffix_rows, strict=True)]
+    target_masks = [[0] * len(prefix) + [1] * len(suffix) for prefix, suffix in zip(prefix_rows, suffix_rows, strict=True)]
+    return score_causal_targets(model, input_rows, target_masks, batch_size=batch_size)
+```
+
+The scorer shifts logits and target masks together, rejects empty/truncated suffix targets, and limits the combined sequence to 1,024 evaluator tokens. Run the same computation for ground-truth references.
+
+- [ ] **Step 3: Write and pass pinned MAUVE tests**
+
+```python
+def test_mauve_uses_local_snapshot_and_aligned_completion_zero(monkeypatch, assets):
+    call = install_fake_mauve(monkeypatch)
+    result = compute_mauve_score(GENERATED_1024, REFERENCES_1024, assets, device_id=0)
+    assert call["featurize_model_name"] == str(assets.model_path)
+    assert call["p_text"] == REFERENCES_1024
+    assert call["q_text"] == GENERATED_1024
+    assert result.sample_count == 1024
+```
+
+The wrapper imports `mauve` lazily, requires `mauve-text==0.3.0`, sets Hugging Face offline variables, uses the pinned local GPT-2-large snapshot, and records seed, bucket count, model revision, and sample count.
+
+- [ ] **Step 4: Implement grouped diversity, entropy, exact-prefix gating, and CLI artifact**
+
+`conditional_evaluate` retokenizes each continuation text independently with the pinned local GPT-2 evaluator tokenizer, records that evaluator revision in the metric artifact, and passes exactly five 64-token-truncated GPT-2 rows for each prompt `0..255` to `compute_grouped_self_bleu`; each candidate uses its other four same-prompt rows as references with BLEU-4 equal weights and method-1 smoothing. `conditional_entropy` uses the first 64 model-native continuation IDs and no prefix tokens. `conditional_evaluate.evaluate` rejects any schedule or prefix mismatch before loading evaluator models and publishes:
+
+```python
+{
+    "schema": "dlb-conditional-metrics-v1",
+    "protocol": "c64_zs_v1",
+    "sample_count": 2048,
+    "quality_sample_count": 1024,
+    "diversity_prompt_count": 256,
+    "samples_sha256": sha256_file(samples_path),
+    "prompt_manifest_sha256": manifest_sha,
+    "metrics": {
+        "conditional_generation_perplexity": generated_ppl,
+        "reference_conditional_perplexity": reference_ppl,
+        "mauve": mauve_result,
+        "grouped_self_bleu": self_bleu_result,
+        "continuation_entropy": entropy_result,
+        "prefix_exact_match_rate": 1.0,
+    },
+}
+```
+
+Run: `pytest tests/test_conditional_perplexity.py tests/test_mauve_score.py tests/test_conditional_evaluate.py tests/test_perplexity.py tests/test_self_bleu.py tests/test_entropy.py -q`
+
+Expected: all conditional and unconditional evaluation tests pass.
+
+- [ ] **Step 5: Commit conditional evaluation**
+
+```bash
+git add evaluation/conditional_perplexity.py evaluation/mauve_score.py \
+  evaluation/conditional_evaluate.py evaluation/self_bleu.py \
+  evaluation/unigram_entropy.py tests/test_conditional_perplexity.py \
+  tests/test_mauve_score.py tests/test_conditional_evaluate.py
+git commit -m "feat: evaluate conditional quality and diversity"
+```
+
+### Task 9: Conditional timing protocol
+
+**Files:**
+
+- Create: `src/dlb/conditional_benchmarking.py`
+- Modify: `src/dlb/benchmarking.py`
+- Modify: `src/dlb/timing.py`
+- Modify: `src/dlb/adapters/base.py`
+- Create: `tests/test_conditional_timing.py`
+
+**Interfaces:**
+
+- Consumes: prompt 0, conditional matrix task, adapter `benchmark_hook`, and existing CUDA timing primitives.
+- Produces: schema `dlb-conditional-timing-v1` with 5 warmups, 32 repeats, batch size 1, full model canvas, and conditional provenance.
+
+- [ ] **Step 1: Write failing timer-boundary and metadata tests**
+
+```python
+def test_conditional_timer_moves_prompt_before_first_clock(monkeypatch, fake_adapter):
+    events = install_timing_spies(monkeypatch, fake_adapter)
+    benchmark_conditional_cell(fake_task(), fake_adapter)
+    assert events.index("prompt.to:cuda") < events.index("clock:start")
+    assert events.count("generate_with_projection") == 5 + 32
+
+
+def test_owt_timing_records_full_canvas_not_metric_slice():
+    metadata = conditional_timing_metadata(fake_task(dataset="owt"))
+    assert metadata["model_length"] == 1024
+    assert metadata["generated_suffix_length"] == 960
+    assert metadata["evaluation_continuation_length"] == 64
+```
+
+- [ ] **Step 2: Run focused timing tests and verify missing conditional module**
+
+Run: `pytest tests/test_conditional_timing.py -q`
+
+Expected: import failure for `dlb.conditional_benchmarking`.
+
+- [ ] **Step 3: Implement conditional benchmark rendering and publication**
+
+Use a `RunRequest` with `generation_mode="conditional_prefix"`, `sample_count=1`, `prompt_count=1`, `diversity_prompt_count=0`, and `completions_per_diversity_prompt=1`. Load prompt 0 and move it to the target GPU before passing the measured closure to `benchmark`. Reuse the current synchronization and raw-duration logic with `warmups=5`, `repeats=32`; projection/clamp calls stay inside `generate_one`.
+
+```python
+metadata.update({
+    "schema": "dlb-conditional-timing-v1",
+    "protocol": "c64_zs_v1",
+    "prompt_id": 0,
+    "prefix_length": 64,
+    "batch_size": 1,
+    "warmups": 5,
+    "repeats": 32,
+    "conditioning_manifest_sha256": task.conditioning_manifest_sha256,
+})
+```
+
+- [ ] **Step 4: Prove unconditional timing remains unchanged**
+
+Run: `pytest tests/test_conditional_timing.py tests/test_timing.py -q`
+
+Expected: conditional timing passes; existing timing schema, warmup/repeat behavior, and benchmark command tests remain green.
+
+- [ ] **Step 5: Commit conditional timing**
+
+```bash
+git add src/dlb/conditional_benchmarking.py src/dlb/benchmarking.py \
+  src/dlb/timing.py src/dlb/adapters/base.py tests/test_conditional_timing.py
+git commit -m "feat: benchmark conditional generation latency"
+```
+
+### Task 10: Strict conditional aggregation
+
+**Files:**
+
+- Create: `src/dlb/conditional_aggregate.py`
+- Create: `scripts/aggregate_conditional_results.py`
+- Create: `tests/test_conditional_aggregate.py`
+
+**Interfaces:**
+
+- Consumes: canonical conditional matrix, unsupported inventory, prompts, sample/run metadata, metrics, and timing artifacts.
+- Produces: `ConditionalAggregateReport`, `aggregate_conditional(root, strict=True, partial=False, output_dir=None)`, `results/conditional/summary/results.csv`, `failures.csv`, `unsupported.csv`, `provenance.json`, and `README.md`.
+
+- [ ] **Step 1: Write failing completeness and provenance tests**
+
+```python
+def test_conditional_aggregate_accepts_complete_bound_cell(complete_conditional_cell):
+    report = aggregate_conditional(complete_conditional_cell.root, strict=True)
+    assert report.complete is True
+    assert report.rows[0]["prefix_exact_match_rate"] == 1.0
+
+
+@pytest.mark.parametrize("mutation,message", [
+    (remove_one_sample, "2048"),
+    (duplicate_completion, "schedule"),
+    (change_prompt_sha, "prompt manifest"),
+    (change_metric_sample_sha, "sample artifact"),
+    (change_timing_steps, "step count"),
+])
+def test_conditional_aggregate_fails_closed(complete_conditional_cell, mutation, message):
+    mutation(complete_conditional_cell)
+    with pytest.raises(IncompleteConditionalMatrixError, match=message):
+        aggregate_conditional(complete_conditional_cell.root, strict=True)
+```
+
+- [ ] **Step 2: Run focused tests and confirm missing aggregator**
+
+Run: `pytest tests/test_conditional_aggregate.py -q`
+
+Expected: import failure for `dlb.conditional_aggregate`.
+
+- [ ] **Step 3: Implement cell linkage and strict matrix accounting**
+
+For each of the 132 tasks, validate sample JSONL first, then require run identity, checkpoint/source/tokenizer/prompt SHA linkage, metric `samples_sha256`, timing protocol/task identity, finite metric values, exact record counts, and prefix rate 1.0. Collect failures with `task_id`, stage, path, and message. Strict mode raises when any task fails; partial mode writes a visibly partial report.
+
+- [ ] **Step 4: Publish deterministic summary files atomically**
+
+```python
+@dataclass(frozen=True)
+class ConditionalAggregateReport:
+    complete: bool
+    rows: Sequence[dict[str, object]]
+    failures: Sequence[dict[str, object]]
+    unsupported: Sequence[dict[str, object]]
+```
+
+Sort result rows by model, dataset, and integer steps. CSV columns include conditional PPL, reference PPL, MAUVE, grouped Self-BLEU, entropy, prefix exact match, median/mean latency, checkpoint provenance, and conditioning implementation label.
+
+Run: `pytest tests/test_conditional_aggregate.py tests/test_aggregate.py -q`
+
+Expected: new strict/partial tests and existing unconditional aggregation tests pass.
+
+- [ ] **Step 5: Commit aggregation**
+
+```bash
+git add src/dlb/conditional_aggregate.py scripts/aggregate_conditional_results.py \
+  tests/test_conditional_aggregate.py
+git commit -m "feat: aggregate conditional benchmark results"
+```
+
+### Task 11: One-cell, serial, four-GPU, and smoke launchers
+
+**Files:**
+
+- Create: `scripts/run_conditional_one.sh`
+- Create: `scripts/run_conditional_all.sh`
+- Create: `scripts/run_conditional_4gpu.sh`
+- Create: `scripts/evaluate_conditional_all.sh`
+- Create: `scripts/evaluate_conditional_4gpu.sh`
+- Create: `scripts/benchmark_conditional_one.sh`
+- Create: `scripts/benchmark_conditional_all.sh`
+- Create: `scripts/benchmark_conditional_4gpu.sh`
+- Create: `scripts/smoke_conditional_all.sh`
+- Create: `scripts/smoke_conditional_4gpu.sh`
+- Modify: `src/dlb/gpu_matrix.py`
+- Create: `tests/test_conditional_scripts.py`
+
+**Interfaces:**
+
+- Consumes: conditional matrix and CLIs from Tasks 1–10.
+- Produces: safe argv-only launchers with serial/resumable and four-GPU modes plus two-prompt/two-completion smoke coverage.
+
+- [ ] **Step 1: Write failing shell contract and dry-run routing tests**
+
+```python
+def test_conditional_one_exports_project_src_and_complete_protocol(tmp_path):
+    invocation = run_with_fake_conda("scripts/run_conditional_one.sh", tmp_path)
+    assert invocation.module == "dlb.runner"
+    assert invocation.option("--generation-mode") == "conditional_prefix"
+    assert invocation.option("--num-samples") == "2048"
+    assert invocation.option("--results-root").endswith("results/conditional")
+
+
+def test_conditional_gpu_dry_run_routes_each_stage(tmp_path):
+    commands = conditional_gpu_dry_run(tmp_path, stages=("generate", "evaluate", "benchmark"))
+    assert [Path(command[0]).name for command in commands] == [
+        "run_conditional_one.sh", "python", "benchmark_conditional_one.sh"
+    ]
+    assert "evaluation.conditional_evaluate" in commands[1]
+```
+
+- [ ] **Step 2: Run tests and verify missing scripts**
+
+Run: `pytest tests/test_conditional_scripts.py -q`
+
+Expected: failures because the conditional scripts do not exist.
+
+- [ ] **Step 3: Implement safe one-cell and serial scripts**
+
+Every script uses Bash arrays, validates integer/model/dataset arguments, quotes every path, regenerates or verifies the conditional matrix before launch, and records failures below `results/conditional/logs/`. The one-cell generator first calls runner `--validate-only`, then launches the registry-selected Conda environment with:
+
+```bash
+runner_args=(
+  --root "$DLB_ROOT" --model "$model" --dataset "$dataset" --steps "$steps"
+  --num-samples 2048 --seed 42 --generation-mode conditional_prefix
+  --conditioning-config "$DLB_ROOT/configs/conditional.yaml"
+  --conditioning-manifest "$manifest"
+  --results-root "$DLB_ROOT/results/conditional"
+)
+```
+
+- [ ] **Step 4: Implement four-GPU routing and smoke schedule**
+
+Add `--protocol conditional` to `dlb.gpu_matrix`; this selects `read_conditional_matrix` and conditional scripts while the omitted/default value keeps existing unconditional routing. Smoke launchers use a separately labeled output root, two prompt IDs, completions 0 and 1, and step counts 1 plus each category's maximum; they never publish into production paths.
+
+Run: `pytest tests/test_conditional_scripts.py tests/test_gpu_matrix.py tests/test_run_one_script.py -q`
+
+Expected: all conditional script and existing GPU/script tests pass.
+
+- [ ] **Step 5: Commit launchers**
+
+```bash
+git add scripts/run_conditional_one.sh scripts/run_conditional_all.sh \
+  scripts/run_conditional_4gpu.sh scripts/evaluate_conditional_all.sh \
+  scripts/evaluate_conditional_4gpu.sh scripts/benchmark_conditional_one.sh \
+  scripts/benchmark_conditional_all.sh scripts/benchmark_conditional_4gpu.sh \
+  scripts/smoke_conditional_all.sh scripts/smoke_conditional_4gpu.sh \
+  src/dlb/gpu_matrix.py tests/test_conditional_scripts.py
+git commit -m "feat: add conditional benchmark launchers"
+```
+
+### Task 12: Documentation, smoke fixtures, and full regression verification
+
+**Files:**
+
+- Modify: `README.md`
+- Modify: `docs/06_generation_and_evaluation.md`
+- Modify: `docs/09_four_gpu_local.md`
+- Create: `tests/fixtures/conditional_samples.jsonl`
+- Modify: tests from Tasks 1–11 only when full-suite failures expose a contract mismatch.
+
+**Interfaces:**
+
+- Consumes: every feature and command added in Tasks 1–11.
+- Produces: operator instructions, zero-shot/OOD interpretation notes, deterministic fixture coverage, and complete verification evidence.
+
+- [ ] **Step 1: Add a small deterministic fixture and end-to-end offline test**
+
+```python
+def test_conditional_offline_pipeline_from_prompts_to_partial_summary(tmp_path):
+    build_fixture_prompts(tmp_path, prompt_count=2)
+    run_fake_conditional_adapter(tmp_path, completions=2)
+    evaluate_fixture_without_mauve(tmp_path, allow_partial=True)
+    report = aggregate_conditional(tmp_path, strict=False, partial=True)
+    assert len(report.rows) == 1
+    assert report.rows[0]["prefix_exact_match_rate"] == 1.0
+```
+
+Run: `pytest tests/test_conditional_prompts.py tests/test_conditional_runner.py tests/test_conditional_evaluate.py tests/test_conditional_aggregate.py -q`
+
+Expected: the offline prompt → fake generation → evaluation → partial aggregate path passes.
+
+- [ ] **Step 2: Document exact server workflow and interpretation boundary**
+
+Document these commands in order:
+
+```bash
+python scripts/build_conditional_prompts.py --root "$PWD" --dataset lm1b
+python scripts/build_conditional_prompts.py --root "$PWD" --dataset owt
+python scripts/verify_conditional_prompts.py --root "$PWD" --dataset all
+bash scripts/smoke_conditional_4gpu.sh --gpus 0,1,2,3
+bash scripts/run_conditional_4gpu.sh --gpus 0,1,2,3
+bash scripts/evaluate_conditional_4gpu.sh --gpus 0,1,2,3
+bash scripts/benchmark_conditional_4gpu.sh --gpus 0,1,2,3
+python scripts/aggregate_conditional_results.py --root "$PWD"
+```
+
+State explicitly that FLM/FMLM/LangFlow conditioning is zero-shot/OOD projection, the comparison does not reproduce conditional fine-tuning, OWT generation uses a 960-token suffix canvas, and reported aligned quality metrics use the first 64 suffix tokens.
+
+- [ ] **Step 3: Run formatting/syntax checks**
+
+Run: `git diff --check`
+
+Run: `python -m compileall -q src evaluation scripts`
+
+Run: `for file in scripts/*conditional*.sh; do bash -n "$file"; done`
+
+Expected: every command exits 0 with no output indicating an error.
+
+- [ ] **Step 4: Run the complete regression suite**
+
+Run: `pytest -q`
+
+Expected: all existing unconditional tests and all conditional tests pass; no tests are skipped because of an accidental online dependency.
+
+- [ ] **Step 5: Commit documentation and final verification assets**
+
+```bash
+git add README.md docs/06_generation_and_evaluation.md \
+  docs/09_four_gpu_local.md tests/fixtures/conditional_samples.jsonl
+git commit -m "docs: add conditional benchmark operating guide"
+```
+
+## Final server acceptance run
+
+The local implementation is complete after Task 12. On the checkpoint/data server, run these acceptance gates in order and stop on the first failure:
+
+1. `python scripts/verify_data.py --root "$PWD"`
+2. `python scripts/verify_checkpoints.py --root "$PWD"`
+3. `python scripts/verify_conditional_prompts.py --root "$PWD" --dataset all`
+4. `bash scripts/smoke_conditional_4gpu.sh --gpus 0,1,2,3`
+5. Inspect smoke artifacts for all sampler families at one and maximum steps.
+6. `bash scripts/run_conditional_4gpu.sh --gpus 0,1,2,3`
+7. `bash scripts/evaluate_conditional_4gpu.sh --gpus 0,1,2,3`
+8. `bash scripts/benchmark_conditional_4gpu.sh --gpus 0,1,2,3`
+9. `python scripts/aggregate_conditional_results.py --root "$PWD"`
+10. Require `complete=true`, `rows=132`, `failures=0`, one RDLM/OWT unsupported record, and prefix exact-match rate `1.0` for every row.

results/_invalid/old_di4c_shape_skip_20260825_095622/samples_duo_di4c/steps_32/run_metadata.json

@@ -0,0 +1,103 @@
+{
+  "checkpoint_lock_id": "recipe:duo_di4c_lm1b:4efe3a3fafa3314f13963e81f828590ac771c101e228735166bd23c21e79b69e",
+  "checkpoint_selection": {
+    "output": "checkpoints/reference_reproduction/duo_di4c/lm1b",
+    "recipe": "duo_di4c_lm1b",
+    "sampling_checkpoint": "student_checkpoints/20000.ckpt",
+    "sampling_config": "config.yaml",
+    "source": "di4c",
+    "source_commit": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+    "teacher_adapter": "uniform_to_absorbing",
+    "teacher_family": "uniform_duo"
+  },
+  "checkpoint_sha256": "60208e9645d0442c20b0d41779b41f498f36bdefa9746bee5cd0b691403f68c2",
+  "checkpoint_teacher_family": "uniform_duo",
+  "command": [
+    "/opt/anaconda3/envs/dlb-di4c/bin/python",
+    "-B",
+    "-u",
+    "/home/ruizzhao/diffusion_baseline/adapters/sample_di4c.py",
+    "--upstream-root",
+    "/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt",
+    "--checkpoint",
+    "/home/ruizzhao/diffusion_baseline/checkpoints/reference_reproduction/duo_di4c/lm1b/student_checkpoints/20000.ckpt",
+    "--config",
+    "/home/ruizzhao/diffusion_baseline/checkpoints/reference_reproduction/duo_di4c/lm1b/config.yaml",
+    "--checkpoint-sha256",
+    "7104cbbd71fa2b62e95f965ced783f6368e6f3b8bbfaaee23e6ba5d47f0c9d66",
+    "--config-sha256",
+    "0626f28a7b07365b945ee55770d1cf59fd6c9ab2ee2877e54eaa075dea8a9eda",
+    "--data-config",
+    "/home/ruizzhao/diffusion_baseline/artifacts/data.yaml",
+    "--downloads-manifest",
+    "/home/ruizzhao/diffusion_baseline/data/manifests/downloads.json",
+    "--tokenizer-snapshot",
+    "/home/ruizzhao/diffusion_baseline/data/raw/huggingface/hub/models--bert-base-uncased/snapshots/86b5e0934494bd15c9632b12f734a8a67f723594",
+    "--output",
+    "/home/ruizzhao/diffusion_baseline/results/samples/lm1b/duo_di4c/steps_32/upstream_token_ids.json",
+    "--sample-count",
+    "1024",
+    "--batch-size",
+    "16",
+    "--num-steps",
+    "32",
+    "--seq-len",
+    "128",
+    "--seed",
+    "42",
+    "--sampler",
+    "ancestral",
+    "--teacher-family",
+    "uniform_duo",
+    "--dataset",
+    "lm1b",
+    "--offline",
+    "true",
+    "--allow-missing-embedded-config",
+    "true"
+  ],
+  "command_sha256": "161b06b6ded77905ed223d323fcb3808dd9ade33c1e34fbe1479c334f6d4c8a4",
+  "config_sha256": "be62fffbe55e7a17bc51113d6dfd4cc680fad40df9e0b5dbdfef70da22081932",
+  "environment": {
+    "cuda_version": null,
+    "cuda_visible_devices": "7",
+    "hostname": "DS210029",
+    "platform": "Linux-5.15.0-186-generic-x86_64-with-glibc2.35",
+    "python": "3.10.20",
+    "torch_version": "2.5.1"
+  },
+  "finished_at": "2026-08-21T02:07:49.732328Z",
+  "identity": {
+    "adapter_identity": "dlb.adapters.di4c:v3|dlb.adapters.di4c:Di4CAdapter|5b83af37672cba7bfa98d900022b1f74a140106369c8610c88338213eaee43b4",
+    "checkpoint_lock_id": "recipe:duo_di4c_lm1b:4efe3a3fafa3314f13963e81f828590ac771c101e228735166bd23c21e79b69e",
+    "checkpoint_selection": {
+      "output": "checkpoints/reference_reproduction/duo_di4c/lm1b",
+      "recipe": "duo_di4c_lm1b",
+      "sampling_checkpoint": "student_checkpoints/20000.ckpt",
+      "sampling_config": "config.yaml",
+      "source": "di4c",
+      "source_commit": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+      "teacher_adapter": "uniform_to_absorbing",
+      "teacher_family": "uniform_duo"
+    },
+    "checkpoint_sha256": "60208e9645d0442c20b0d41779b41f498f36bdefa9746bee5cd0b691403f68c2",
+    "checkpoint_teacher_family": "uniform_duo",
+    "command_sha256": "161b06b6ded77905ed223d323fcb3808dd9ade33c1e34fbe1479c334f6d4c8a4",
+    "config_sha256": "be62fffbe55e7a17bc51113d6dfd4cc680fad40df9e0b5dbdfef70da22081932",
+    "dataset_id": "lm1b",
+    "device": null,
+    "environment": "dlb-di4c",
+    "model_id": "duo_di4c",
+    "results_root": null,
+    "run_id": "duo_di4c-lm1b-steps-32",
+    "sample_count": 1024,
+    "seed": 42,
+    "source_sha256": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+    "step_count": 32
+  },
+  "source_sha256": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+  "started_at": "2026-08-21T02:07:15.248756Z",
+  "status": "succeeded",
+  "stderr_log": "/home/ruizzhao/diffusion_baseline/results/samples/lm1b/duo_di4c/steps_32/stderr.log",
+  "stdout_log": "/home/ruizzhao/diffusion_baseline/results/samples/lm1b/duo_di4c/steps_32/stdout.log"
+}

results/_invalid/old_di4c_shape_skip_20260825_095622/samples_mdlm_di4c/steps_4/run_metadata.json

@@ -0,0 +1,103 @@
+{
+  "checkpoint_lock_id": "recipe:mdlm_di4c_lm1b:4efe3a3fafa3314f13963e81f828590ac771c101e228735166bd23c21e79b69e",
+  "checkpoint_selection": {
+    "output": "checkpoints/reference_reproduction/mdlm_di4c/lm1b",
+    "recipe": "mdlm_di4c_lm1b",
+    "sampling_checkpoint": "student_checkpoints/20000.ckpt",
+    "sampling_config": "config.yaml",
+    "source": "di4c",
+    "source_commit": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+    "teacher_adapter": "masked_to_absorbing",
+    "teacher_family": "masked_mdlm"
+  },
+  "checkpoint_sha256": "d6b14edd7f897871ed6381527f604493ac680712de055a3757e4e73dccd2e777",
+  "checkpoint_teacher_family": "masked_mdlm",
+  "command": [
+    "/opt/anaconda3/envs/dlb-di4c/bin/python",
+    "-B",
+    "-u",
+    "/home/ruizzhao/diffusion_baseline/adapters/sample_di4c.py",
+    "--upstream-root",
+    "/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt",
+    "--checkpoint",
+    "/home/ruizzhao/diffusion_baseline/checkpoints/reference_reproduction/mdlm_di4c/lm1b/student_checkpoints/20000.ckpt",
+    "--config",
+    "/home/ruizzhao/diffusion_baseline/checkpoints/reference_reproduction/mdlm_di4c/lm1b/config.yaml",
+    "--checkpoint-sha256",
+    "29ea21a518da604466ec425458155a3880ed6c03bdaaf7d00ad958a761c6c46d",
+    "--config-sha256",
+    "afaecee89f9071bb9f2761b5839927858cb24e8360c77a79b272767aad09a488",
+    "--data-config",
+    "/home/ruizzhao/diffusion_baseline/artifacts/data.yaml",
+    "--downloads-manifest",
+    "/home/ruizzhao/diffusion_baseline/data/manifests/downloads.json",
+    "--tokenizer-snapshot",
+    "/home/ruizzhao/diffusion_baseline/data/raw/huggingface/hub/models--bert-base-uncased/snapshots/86b5e0934494bd15c9632b12f734a8a67f723594",
+    "--output",
+    "/home/ruizzhao/diffusion_baseline/results/samples/lm1b/mdlm_di4c/steps_4/upstream_token_ids.json",
+    "--sample-count",
+    "1024",
+    "--batch-size",
+    "16",
+    "--num-steps",
+    "4",
+    "--seq-len",
+    "128",
+    "--seed",
+    "42",
+    "--sampler",
+    "ancestral",
+    "--teacher-family",
+    "masked_mdlm",
+    "--dataset",
+    "lm1b",
+    "--offline",
+    "true",
+    "--allow-missing-embedded-config",
+    "true"
+  ],
+  "command_sha256": "d76b9ff0b9cff4a718629ac7eed9456bc6c97c8e687bf98b78fb25117121f21b",
+  "config_sha256": "be62fffbe55e7a17bc51113d6dfd4cc680fad40df9e0b5dbdfef70da22081932",
+  "environment": {
+    "cuda_version": null,
+    "cuda_visible_devices": "7",
+    "hostname": "DS210029",
+    "platform": "Linux-5.15.0-186-generic-x86_64-with-glibc2.35",
+    "python": "3.10.20",
+    "torch_version": "2.5.1"
+  },
+  "finished_at": "2026-08-21T02:08:57.175679Z",
+  "identity": {
+    "adapter_identity": "dlb.adapters.di4c:v3|dlb.adapters.di4c:Di4CAdapter|5b83af37672cba7bfa98d900022b1f74a140106369c8610c88338213eaee43b4",
+    "checkpoint_lock_id": "recipe:mdlm_di4c_lm1b:4efe3a3fafa3314f13963e81f828590ac771c101e228735166bd23c21e79b69e",
+    "checkpoint_selection": {
+      "output": "checkpoints/reference_reproduction/mdlm_di4c/lm1b",
+      "recipe": "mdlm_di4c_lm1b",
+      "sampling_checkpoint": "student_checkpoints/20000.ckpt",
+      "sampling_config": "config.yaml",
+      "source": "di4c",
+      "source_commit": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+      "teacher_adapter": "masked_to_absorbing",
+      "teacher_family": "masked_mdlm"
+    },
+    "checkpoint_sha256": "d6b14edd7f897871ed6381527f604493ac680712de055a3757e4e73dccd2e777",
+    "checkpoint_teacher_family": "masked_mdlm",
+    "command_sha256": "d76b9ff0b9cff4a718629ac7eed9456bc6c97c8e687bf98b78fb25117121f21b",
+    "config_sha256": "be62fffbe55e7a17bc51113d6dfd4cc680fad40df9e0b5dbdfef70da22081932",
+    "dataset_id": "lm1b",
+    "device": null,
+    "environment": "dlb-di4c",
+    "model_id": "mdlm_di4c",
+    "results_root": null,
+    "run_id": "mdlm_di4c-lm1b-steps-4",
+    "sample_count": 1024,
+    "seed": 42,
+    "source_sha256": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+    "step_count": 4
+  },
+  "source_sha256": "ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3",
+  "started_at": "2026-08-21T02:08:41.813188Z",
+  "status": "succeeded",
+  "stderr_log": "/home/ruizzhao/diffusion_baseline/results/samples/lm1b/mdlm_di4c/steps_4/stderr.log",
+  "stdout_log": "/home/ruizzhao/diffusion_baseline/results/samples/lm1b/mdlm_di4c/steps_4/stdout.log"
+}

results/_invalid/old_di4c_shape_skip_20260825_095622/timing_mdlm_di4c/steps_4/timing.json

@@ -0,0 +1 @@
+{"metadata":{"adapter_identity":"dlb.adapters.di4c:v3|dlb.adapters.di4c:Di4CAdapter|5b83af37672cba7bfa98d900022b1f74a140106369c8610c88338213eaee43b4","attempt_id":"3de92da2acbc4ab38e115eebb5e5cff5","checkpoint_lock_id":"recipe:mdlm_di4c_lm1b:4efe3a3fafa3314f13963e81f828590ac771c101e228735166bd23c21e79b69e","checkpoint_selection":{"output":"checkpoints/reference_reproduction/mdlm_di4c/lm1b","recipe":"mdlm_di4c_lm1b","sampling_checkpoint":"student_checkpoints/20000.ckpt","sampling_config":"config.yaml","source":"di4c","source_commit":"ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3","teacher_adapter":"masked_to_absorbing","teacher_family":"masked_mdlm"},"checkpoint_sha256":"d6b14edd7f897871ed6381527f604493ac680712de055a3757e4e73dccd2e777","checkpoint_teacher_family":"masked_mdlm","config_sha256":"be62fffbe55e7a17bc51113d6dfd4cc680fad40df9e0b5dbdfef70da22081932","cuda_runtime_version":"12.4","dataset":"lm1b","environment":"dlb-di4c","gpu_compute_capability":"9.0","gpu_index":0,"gpu_name":"NVIDIA H200 NVL","model":"mdlm_di4c","nvidia_driver_version":"575.57.08","parameter_precision":"fp32","precision":"bf16-mixed","precision_evidence":"static_policy_bound_to_checkpoint_and_runtime_code_not_runtime_autocast_observation","precision_policy":"di4c:pinned_bf16_mixed_config_and_internal_autocast","precision_policy_binding":{"adapter_identity":"dlb.adapters.di4c:v3|dlb.adapters.di4c:Di4CAdapter|5b83af37672cba7bfa98d900022b1f74a140106369c8610c88338213eaee43b4","checkpoint_lock_id":"recipe:mdlm_di4c_lm1b:4efe3a3fafa3314f13963e81f828590ac771c101e228735166bd23c21e79b69e","checkpoint_selection":{"output":"checkpoints/reference_reproduction/mdlm_di4c/lm1b","recipe":"mdlm_di4c_lm1b","sampling_checkpoint":"student_checkpoints/20000.ckpt","sampling_config":"config.yaml","source":"di4c","source_commit":"ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3","teacher_adapter":"masked_to_absorbing","teacher_family":"masked_mdlm"},"checkpoint_sha256":"d6b14edd7f897871ed6381527f604493ac680712de055a3757e4e73dccd2e777","dataset":"lm1b","experiment_config_sha256":"be62fffbe55e7a17bc51113d6dfd4cc680fad40df9e0b5dbdfef70da22081932","model":"mdlm_di4c","source_commit":"ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3","upstream":"di4c"},"pytorch_compiled_cuda_toolkit":"12.4","requested_precision":"author","runtime_code_binding":[{"kind":"sampling_callable","path":"/home/ruizzhao/diffusion_baseline/adapters/_distilled_runtime.py","sha256":"a81d2f1a09bc895c9775f5b583ec4e4b8245d6e7b518728e163a03b872554992","symbol":"benchmark_model.<locals>.<lambda>"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/core/diffusion/noise_schedule.py","sha256":"b2c06e11a4947b306db1c19eac181b99bbc6b36520526ebb36639696c95dcb21","symbol":"LogLinearNoise"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/core/distill/multi_round_sdtt.py","sha256":"75c61fbd1d3e1b87e10b25d67c0143ba0995753f579e0282bc1e3559c145704c","symbol":"MultiRoundSDTT"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"DDiTBlock"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"DDitFinalLayer"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"DIT"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"EmbeddingLayer"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"LayerNorm"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"Rotary"},{"kind":"loaded_module","path":"/home/ruizzhao/diffusion_baseline/upstreams/di4c/sdtt/src/sdtt/models/dit_orig.py","sha256":"c2e7ced4ccbb92bcf9e6fdc0fc2b41130447d8d15e5d696e7f3a927177578912","symbol":"TimestepEmbedder"},{"kind":"loaded_module","path":"/opt/anaconda3/envs/dlb-di4c/lib/python3.10/site-packages/torch/nn/modules/activation.py","sha256":"1e748e0df0d70491fe82f0178f32126ee6ee138a53de7fc76463af10c75f5477","symbol":"GELU"},{"kind":"loaded_module","path":"/opt/anaconda3/envs/dlb-di4c/lib/python3.10/site-packages/torch/nn/modules/activation.py","sha256":"1e748e0df0d70491fe82f0178f32126ee6ee138a53de7fc76463af10c75f5477","symbol":"SiLU"},{"kind":"loaded_module","path":"/opt/anaconda3/envs/dlb-di4c/lib/python3.10/site-packages/torch/nn/modules/container.py","sha256":"33af8d1fe4fb542cbba5542c5079b1bd8ef8a6493abbef329411f71b2071d24f","symbol":"ModuleList"},{"kind":"loaded_module","path":"/opt/anaconda3/envs/dlb-di4c/lib/python3.10/site-packages/torch/nn/modules/container.py","sha256":"33af8d1fe4fb542cbba5542c5079b1bd8ef8a6493abbef329411f71b2071d24f","symbol":"Sequential"},{"kind":"loaded_module","path":"/opt/anaconda3/envs/dlb-di4c/lib/python3.10/site-packages/torch/nn/modules/dropout.py","sha256":"1fc9974c3cf2078dd4bc257f73afb6a6714adfec2e9d099d47cf923e766d3490","symbol":"Dropout"},{"kind":"loaded_module","path":"/opt/anaconda3/envs/dlb-di4c/lib/python3.10/site-packages/torch/nn/modules/linear.py","sha256":"d7f5cadf773deb5ab4bcc9f57414e8239b2859c70d2aa6f141576de1ec918823","symbol":"Linear"}],"seed":42,"source_commit":"ac61ff9fe8e85120f9e1d2a8c5a332f8b8353dd3","steps":4,"synchronization_policy":"torch.cuda.synchronize_before_start_and_after_generate"},"schema":"dlb-generation-timing-v1","timing":{"batch_size":1,"exclusions":["model_and_checkpoint_loading","first_compilation","token_decoding","metrics","file_io"],"median_seconds":0.028812396456487477,"mode":"primary_latency","num_timed_samples":32,"raw_durations_seconds":[0.028952325927093625,0.02889296505600214,0.02881482499651611,0.028835597913712263,0.028863610001280904,0.028826443012803793,0.028941920027136803,0.028878462966531515,0.028866074047982693,0.028866023989394307,0.028870980953797698,0.028861936880275607,0.028891792986541986,0.028822577092796564,0.028789767064154148,0.028745889198035002,0.028809967916458845,0.02874415717087686,0.028673017164692283,0.02875470300205052,0.028752220096066594,0.030406136997044086,0.02901422092691064,0.028689061990007758,0.028658536029979587,0.02869494096376002,0.028659117175266147,0.028743675909936428,0.028751909034326673,0.02867855690419674,0.0286307530477643,0.02864584606140852],"repeats":32,"seconds_per_sample":0.028844625390775036,"standard_deviation_convention":"population","standard_deviation_seconds":0.00029661149222713547,"warmups":5}}

results/elf-gpu01/logs/20260913T065838-1485984/owt-prefix__c64-text-t5__steps_1__seed_42__compile_0__generate.log

@@ -0,0 +1,259 @@
+["/opt/anaconda3/envs/dlb-elf/bin/python", "-B", "/home/ruizzhao/diffusion_baseline/scripts/run_elf.py", "generate", "--root", "/home/ruizzhao/diffusion_baseline", "--task", "owt-prefix", "--steps", "1", "--seed", "42", "--batch-size", "8", "--num-samples", "1024", "--output", "/home/ruizzhao/diffusion_baseline/results/elf-gpu01/quality/owt-prefix/c64-text-t5/steps_1/seed_42/compile_0", "--input", "/home/ruizzhao/diffusion_baseline/data/elf/owt-prefix.jsonl", "--diversity"]
+Checking 1024 conditions before loading ELF weights: /home/ruizzhao/diffusion_baseline/data/elf/owt-prefix.jsonl
+ELF generate: task=owt-prefix, steps=1, split=unconditional, output=/home/ruizzhao/diffusion_baseline/results/elf-gpu01/quality/owt-prefix/c64-text-t5/steps_1/seed_42/compile_0
+8/2048 samples
+16/2048 samples
+24/2048 samples
+32/2048 samples
+40/2048 samples
+48/2048 samples
+56/2048 samples
+64/2048 samples
+72/2048 samples
+80/2048 samples
+88/2048 samples
+96/2048 samples
+104/2048 samples
+112/2048 samples
+120/2048 samples
+128/2048 samples
+136/2048 samples
+144/2048 samples
+152/2048 samples
+160/2048 samples
+168/2048 samples
+176/2048 samples
+184/2048 samples
+192/2048 samples
+200/2048 samples
+208/2048 samples
+216/2048 samples
+224/2048 samples
+232/2048 samples
+240/2048 samples
+248/2048 samples
+256/2048 samples
+264/2048 samples
+272/2048 samples
+280/2048 samples
+288/2048 samples
+296/2048 samples
+304/2048 samples
+312/2048 samples
+320/2048 samples
+328/2048 samples
+336/2048 samples
+344/2048 samples
+352/2048 samples
+360/2048 samples
+368/2048 samples
+376/2048 samples
+384/2048 samples
+392/2048 samples
+400/2048 samples
+408/2048 samples
+416/2048 samples
+424/2048 samples
+432/2048 samples
+440/2048 samples
+448/2048 samples
+456/2048 samples
+464/2048 samples
+472/2048 samples
+480/2048 samples
+488/2048 samples
+496/2048 samples
+504/2048 samples
+512/2048 samples
+520/2048 samples
+528/2048 samples
+536/2048 samples
+544/2048 samples
+552/2048 samples
+560/2048 samples
+568/2048 samples
+576/2048 samples
+584/2048 samples
+592/2048 samples
+600/2048 samples
+608/2048 samples
+616/2048 samples
+624/2048 samples
+632/2048 samples
+640/2048 samples
+648/2048 samples
+656/2048 samples
+664/2048 samples
+672/2048 samples
+680/2048 samples
+688/2048 samples
+696/2048 samples
+704/2048 samples
+712/2048 samples
+720/2048 samples
+728/2048 samples
+736/2048 samples
+744/2048 samples
+752/2048 samples
+760/2048 samples
+768/2048 samples
+776/2048 samples
+784/2048 samples
+792/2048 samples
+800/2048 samples
+808/2048 samples
+816/2048 samples
+824/2048 samples
+832/2048 samples
+840/2048 samples
+848/2048 samples
+856/2048 samples
+864/2048 samples
+872/2048 samples
+880/2048 samples
+888/2048 samples
+896/2048 samples
+904/2048 samples
+912/2048 samples
+920/2048 samples
+928/2048 samples
+936/2048 samples
+944/2048 samples
+952/2048 samples
+960/2048 samples
+968/2048 samples
+976/2048 samples
+984/2048 samples
+992/2048 samples
+1000/2048 samples
+1008/2048 samples
+1016/2048 samples
+1024/2048 samples
+1032/2048 samples
+1040/2048 samples
+1048/2048 samples
+1056/2048 samples
+1064/2048 samples
+1072/2048 samples
+1080/2048 samples
+1088/2048 samples
+1096/2048 samples
+1104/2048 samples
+1112/2048 samples
+1120/2048 samples
+1128/2048 samples
+1136/2048 samples
+1144/2048 samples
+1152/2048 samples
+1160/2048 samples
+1168/2048 samples
+1176/2048 samples
+1184/2048 samples
+1192/2048 samples
+1200/2048 samples
+1208/2048 samples
+1216/2048 samples
+1224/2048 samples
+1232/2048 samples
+1240/2048 samples
+1248/2048 samples
+1256/2048 samples
+1264/2048 samples
+1272/2048 samples
+1280/2048 samples
+1288/2048 samples
+1296/2048 samples
+1304/2048 samples
+1312/2048 samples
+1320/2048 samples
+1328/2048 samples
+1336/2048 samples
+1344/2048 samples
+1352/2048 samples
+1360/2048 samples
+1368/2048 samples
+1376/2048 samples
+1384/2048 samples
+1392/2048 samples
+1400/2048 samples
+1408/2048 samples
+1416/2048 samples
+1424/2048 samples
+1432/2048 samples
+1440/2048 samples
+1448/2048 samples
+1456/2048 samples
+1464/2048 samples
+1472/2048 samples
+1480/2048 samples
+1488/2048 samples
+1496/2048 samples
+1504/2048 samples
+1512/2048 samples
+1520/2048 samples
+1528/2048 samples
+1536/2048 samples
+1544/2048 samples
+1552/2048 samples
+1560/2048 samples
+1568/2048 samples
+1576/2048 samples
+1584/2048 samples
+1592/2048 samples
+1600/2048 samples
+1608/2048 samples
+1616/2048 samples
+1624/2048 samples
+1632/2048 samples
+1640/2048 samples
+1648/2048 samples
+1656/2048 samples
+1664/2048 samples
+1672/2048 samples
+1680/2048 samples
+1688/2048 samples
+1696/2048 samples
+1704/2048 samples
+1712/2048 samples
+1720/2048 samples
+1728/2048 samples
+1736/2048 samples
+1744/2048 samples
+1752/2048 samples
+1760/2048 samples
+1768/2048 samples
+1776/2048 samples
+1784/2048 samples
+1792/2048 samples
+1800/2048 samples
+1808/2048 samples
+1816/2048 samples
+1824/2048 samples
+1832/2048 samples
+1840/2048 samples
+1848/2048 samples
+1856/2048 samples
+1864/2048 samples
+1872/2048 samples
+1880/2048 samples
+1888/2048 samples
+1896/2048 samples
+1904/2048 samples
+1912/2048 samples
+1920/2048 samples
+1928/2048 samples
+1936/2048 samples
+1944/2048 samples
+1952/2048 samples
+1960/2048 samples
+1968/2048 samples
+1976/2048 samples
+1984/2048 samples
+1992/2048 samples
+2000/2048 samples
+2008/2048 samples
+2016/2048 samples
+2024/2048 samples
+2032/2048 samples
+2040/2048 samples
+2048/2048 samples

results/elf-gpu01/quality/owt-prefix/c64-text-t5/steps_1/seed_42/compile_0/request.json

@@ -0,0 +1,51 @@
+{
+  "schema": "dlb-elf-v1",
+  "task": "owt-prefix",
+  "model": "ELF-B",
+  "source_commit": "b29d8833609e9ab7f67cd9da39435ac5cea04837",
+  "checkpoint_task": "owt",
+  "checkpoint_selection": "ema_params1",
+  "checkpoint_sha256": "52c21bfb7f920e785e0e780645c411c94e4541af4cee8f85b6f555f826d4c283",
+  "assets_manifest_sha256": "213c6827168523e800868db2d2ee2f3c4ed3d030fdbd15fc502c907e429bee0a",
+  "source_config_sha256": "6bbe69ad55e5d890affe61d5b89ae03ff4087c8933cdc36832ffeaa5e16375b5",
+  "runner_sha256": "19dda543105c787524473128fbac2bc8fd7efd58fa95fa4f1954b9155ebb8a65",
+  "helper_sha256": "ff79c244d7b893bb7353677c4bd7e206f6a486193b2bbfd150282dbee95d307c",
+  "lock_sha256": "b801cd97165cfd78a9f41d6dcbaa4bbf51c60df794237e8a981f8b1520b896a5",
+  "steps": 1,
+  "sampling": {
+    "sampling_method": "sde",
+    "cfg": 1.0,
+    "sc_cfg": 3.0,
+    "gamma": 2.0
+  },
+  "seed": 42,
+  "batch_size": 8,
+  "precision": "fp32 parameters/latents; official bf16 forward autocast; fp32 output heads",
+  "matmul_precision": "high",
+  "compile": false,
+  "model_canvas_t5_tokens": 1024,
+  "input": {
+    "schema": "elf-input-v1",
+    "count": 1024,
+    "sha256": "3df4bc0c58454494944c86e374388f83ef3a4c2168a6c06f6b70a217cc8e3958",
+    "task": "owt-prefix",
+    "protocol": "c64_text_t5_v1",
+    "source_sha256": "68907c7d4eb5104dbaea6d136a951635a11eb46c0f3e8f417d5f406e1ca834fc"
+  },
+  "protocol": "c64_text_t5_v1",
+  "conditioning": "zero_shot_ood_native_projection",
+  "condition_tokenization_policy": "c64_raw_no_special_tokens_v1",
+  "elf_forward_calls_per_sample": 2,
+  "condition_encoder_calls_per_sample": 1,
+  "untimed_preflight": {
+    "calls": 2,
+    "prefix_checked_calls": 2
+  },
+  "gpu_name": "NVIDIA H200 NVL",
+  "gpu_index": 0,
+  "gpu_compute_capability": "9.0",
+  "cuda_runtime_version": "12.4",
+  "pytorch_compiled_cuda_toolkit": "12.4",
+  "nvidia_driver_version": "575.57.08",
+  "synchronization_policy": "torch.cuda.synchronize_before_start_and_after_generate"
+}

results/elf-gpu01/quality/xsum/validation/steps_4/seed_42/compile_0/request.json

@@ -0,0 +1,60 @@
+{
+  "schema": "dlb-elf-v1",
+  "task": "xsum",
+  "model": "ELF-B",
+  "source_commit": "b29d8833609e9ab7f67cd9da39435ac5cea04837",
+  "checkpoint_task": "xsum",
+  "checkpoint_selection": "ema_params1",
+  "checkpoint_sha256": "fb2cb9a2aba0328d0de30d53800c0976a019303b9a31f16051981982ed8795ae",
+  "assets_manifest_sha256": "213c6827168523e800868db2d2ee2f3c4ed3d030fdbd15fc502c907e429bee0a",
+  "source_config_sha256": "8ee817a563626df6f98bb96b91df378d3c459cc002923a5b4a28b3b17bf41ca5",
+  "runner_sha256": "19dda543105c787524473128fbac2bc8fd7efd58fa95fa4f1954b9155ebb8a65",
+  "helper_sha256": "ff79c244d7b893bb7353677c4bd7e206f6a486193b2bbfd150282dbee95d307c",
+  "lock_sha256": "b801cd97165cfd78a9f41d6dcbaa4bbf51c60df794237e8a981f8b1520b896a5",
+  "steps": 4,
+  "sampling": {
+    "sampling_method": "ode",
+    "cfg": 2.0,
+    "sc_cfg": 1.0,
+    "gamma": 0.0
+  },
+  "seed": 42,
+  "batch_size": 8,
+  "precision": "fp32 parameters/latents; official bf16 forward autocast; fp32 output heads",
+  "matmul_precision": "high",
+  "compile": false,
+  "model_canvas_t5_tokens": 1088,
+  "input": {
+    "schema": "elf-input-v1",
+    "count": 11332,
+    "sha256": "98d21431c1df775e0f5585f509fa5d412b64e43b7a04db08e8f458c301c110ed",
+    "task": "xsum",
+    "split": "validation",
+    "asset": {
+      "repo_id": "EdinburghNLP/xsum",
+      "revision": "7d4d486c2f8ef850b1a11aead99b894ff3dd7da9",
+      "repo_type": "dataset",
+      "patterns": [
+        "data/validation-*.parquet",
+        "data/test-*.parquet"
+      ]
+    },
+    "reader": "pyarrow_parquet_v1"
+  },
+  "protocol": "elf_native_v1",
+  "conditioning": "task_trained",
+  "condition_tokenization_policy": "released_ids_or_raw_plus_eos_then_source_cap_v2",
+  "elf_forward_calls_per_sample": 9,
+  "condition_encoder_calls_per_sample": 1,
+  "untimed_preflight": {
+    "calls": 9,
+    "prefix_checked_calls": 9
+  },
+  "gpu_name": "NVIDIA H200 NVL",
+  "gpu_index": 0,
+  "gpu_compute_capability": "9.0",
+  "cuda_runtime_version": "12.4",
+  "pytorch_compiled_cuda_toolkit": "12.4",
+  "nvidia_driver_version": "575.57.08",
+  "synchronization_policy": "torch.cuda.synchronize_before_start_and_after_generate"
+}

results/elf-h200-gpu2/logs/smoke_xsum.log

@@ -0,0 +1,2 @@
+2/2 samples
+2/2 samples

results/elf-owt-baseline-eval-owt-prefix/steps_32/metrics.json

@@ -0,0 +1,70 @@
+{
+  "protocol": "elf_owt_public_baseline_eval_v1",
+  "task": "owt-prefix",
+  "steps": 32,
+  "source_run": "/home/ruizzhao/diffusion_baseline/results/elf-gpu01/quality/owt-prefix/c64-text-t5/steps_32/seed_42/compile_0",
+  "samples_sha256": "d0d9f5833ccf8a9c2e38e3707ba118e4a93f8b2646920cb1fde7e91b8132ff9e",
+  "generation_manifest_sha256": "555290477f6dcf6a67cc5343193352be2ea5c18594786411b26bd0517212dc5d",
+  "assets_manifest_sha256": "213c6827168523e800868db2d2ee2f3c4ed3d030fdbd15fc502c907e429bee0a",
+  "evaluator": {
+    "evaluate_elf_owt_baseline.py": "14543ff030dcc81b94327737f61d0160f7cf56f2805a36c0c02708e4afe6268d",
+    "generative_perplexity.py": "d2f0a6b7513dd8267a6af63ca269dbf80f2bf449e9074ee3bd9b3c8340d30377",
+    "conditional_perplexity.py": "8344d2b60221c95ed979ea9ddc241a5430b2f41b27ab6e7d9d3aabcd5eefbb30",
+    "conditional_evaluate.py": "91db381ab153f7f8079d6e6048d7b05cc19b755f3e8a39284d63694147a74698",
+    "unigram_entropy.py": "22bc98226a73ff232f1bd159d2a5efd851689f54a715ba037c9bc1e2c2d90a70",
+    "self_bleu.py": "60c0b3d52034ca67d9cf517871dc804bf16d6b9f03e6a3fc5bb3b164f726b4d9"
+  },
+  "batch_size": 8,
+  "prompts_sha256": "68907c7d4eb5104dbaea6d136a951635a11eb46c0f3e8f417d5f406e1ca834fc",
+  "sample_count": 2048,
+  "prompt_count": 1024,
+  "metrics": {
+    "entropy_gpt2_nats": 3.725415810106105,
+    "conditional_ppl": {
+      "perplexity": 60.56163680457397,
+      "total_nll": 538236.2602539062,
+      "valid_token_count": 131160,
+      "sample_count": 2048,
+      "batch_size": 8,
+      "context_length": 1024,
+      "truncation": "right",
+      "model_id": "gpt2-large",
+      "model_revision": "32b71b12589c2f8d625668d2335a01cac3249519",
+      "tokenizer_id": "gpt2",
+      "tokenizer_revision": "607a30d783dfa663caf39e06633721c8d4cfcd7e",
+      "aggregation": "sum_nll_over_sum_valid_next_tokens"
+    },
+    "grouped_self_bleu": {
+      "score": 0.03318342181743137,
+      "prompt_count": 256,
+      "completions_per_prompt": 5,
+      "sample_count": 1280,
+      "tokenization": "gpt2",
+      "ngram_order": 4,
+      "weights": [
+        0.25,
+        0.25,
+        0.25,
+        0.25
+      ],
+      "smoothing": "chen_cherry_method1",
+      "aggregation": "mean_prompt_group_self_bleu",
+      "slice": "generated_source_tokens_64_128_only"
+    }
+  },
+  "valid": true,
+  "length_diagnostics": {
+    "mean": 868.18603515625,
+    "min": 631,
+    "max": 985,
+    "below_64_count": 0,
+    "above_1024_count": 0
+  },
+  "short_sample_ids": [],
+  "native_tokenizer": "t5-small",
+  "scoring_tokenizer": "gpt2",
+  "scoring_limit": 64,
+  "completion_scope": "all_saved_completions",
+  "output_policy": "released ELF EOS-trimmed decoded text; GPT-2 retokenized; no fabricated padding",
+  "ppl_policy": "existing compute_conditional_gen_ppl; canonical prefix IDs; decode joined IDs then retokenize; prompt loss excluded"
+}

results/elf-timing-gpu0-20260913T083438-1652790/environment/owt-prefix_validation_s32-after.txt

@@ -0,0 +1,20 @@
+Sun Sep 13 16:43:31 2026       
++-----------------------------------------------------------------------------------------+
+| NVIDIA-SMI 575.57.08              Driver Version: 575.57.08      CUDA Version: 12.9     |
+|-----------------------------------------+------------------------+----------------------+
+| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
+| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
+|                                         |                        |               MIG M. |
+|=========================================+========================+======================|
+|   0  NVIDIA H200 NVL                Off |   00000000:06:00.0 Off |                    0 |
+| N/A   36C    P0            101W /  600W |       0MiB / 143771MiB |      0%      Default |
+|                                         |                        |             Disabled |
++-----------------------------------------+------------------------+----------------------+
+                                                                                         
++-----------------------------------------------------------------------------------------+
+| Processes:                                                                              |
+|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
+|        ID   ID                                                               Usage      |
+|=========================================================================================|
+|  No running processes found                                                             |
++-----------------------------------------------------------------------------------------+

results/elf-timing-gpu1-20260915T091449-470600/environment/owt-prefix_validation_s1024-after.txt

@@ -0,0 +1,20 @@
+Tue Sep 15 17:29:09 2026       
++-----------------------------------------------------------------------------------------+
+| NVIDIA-SMI 575.57.08              Driver Version: 575.57.08      CUDA Version: 12.9     |
+|-----------------------------------------+------------------------+----------------------+
+| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
+| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
+|                                         |                        |               MIG M. |
+|=========================================+========================+======================|
+|   1  NVIDIA H200 NVL                Off |   00000000:07:00.0 Off |                    0 |
+| N/A   39C    P0             98W /  600W |       0MiB / 143771MiB |      0%      Default |
+|                                         |                        |             Disabled |
++-----------------------------------------+------------------------+----------------------+
+                                                                                         
++-----------------------------------------------------------------------------------------+
+| Processes:                                                                              |
+|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
+|        ID   ID                                                               Usage      |
+|=========================================================================================|
+|  No running processes found                                                             |
++-----------------------------------------------------------------------------------------+

results/elf-timing-gpu1-20260915T091449-470600/environment/owt_validation_s1024-after.txt

@@ -0,0 +1,20 @@
+Tue Sep 15 17:20:20 2026       
++-----------------------------------------------------------------------------------------+
+| NVIDIA-SMI 575.57.08              Driver Version: 575.57.08      CUDA Version: 12.9     |
+|-----------------------------------------+------------------------+----------------------+
+| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
+| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
+|                                         |                        |               MIG M. |
+|=========================================+========================+======================|
+|   1  NVIDIA H200 NVL                Off |   00000000:07:00.0 Off |                    0 |
+| N/A   41C    P0             99W /  600W |       0MiB / 143771MiB |      0%      Default |
+|                                         |                        |             Disabled |
++-----------------------------------------+------------------------+----------------------+
+                                                                                         
++-----------------------------------------------------------------------------------------+
+| Processes:                                                                              |
+|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
+|        ID   ID                                                               Usage      |
+|=========================================================================================|
+|  No running processes found                                                             |
++-----------------------------------------------------------------------------------------+

results/logs/4gpu-benchmark-candi-lm1b-steps-1.err

@@ -0,0 +1,14 @@
+Seed set to 42
+/home/ruizzhao/diffusion_baseline/upstreams/candi/algo.py:691: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).
+  self.continuous_noise = torch.tensor(self.continuous_noise)
+/home/ruizzhao/diffusion_baseline/upstreams/candi/algo.py:692: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).
+  self.discrete_noise = torch.tensor(self.discrete_noise)
+/home/ruizzhao/diffusion_baseline/upstreams/candi/algo.py:861: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(dtype=torch.float32):
+/home/ruizzhao/diffusion_baseline/upstreams/candi/models/dit_cont.py:533: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(dtype=torch.bfloat16):
+/home/ruizzhao/diffusion_baseline/upstreams/candi/models/dit_cont.py:157: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(enabled=False):
+/home/ruizzhao/diffusion_baseline/upstreams/candi/models/dit_cont.py:112: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(enabled=False):
+

results/logs/4gpu-benchmark-candi-lm1b-steps-16.err

@@ -0,0 +1,14 @@
+Seed set to 42
+/home/ruizzhao/diffusion_baseline/upstreams/candi/algo.py:691: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).
+  self.continuous_noise = torch.tensor(self.continuous_noise)
+/home/ruizzhao/diffusion_baseline/upstreams/candi/algo.py:692: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).
+  self.discrete_noise = torch.tensor(self.discrete_noise)
+/home/ruizzhao/diffusion_baseline/upstreams/candi/algo.py:861: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(dtype=torch.float32):
+/home/ruizzhao/diffusion_baseline/upstreams/candi/models/dit_cont.py:533: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(dtype=torch.bfloat16):
+/home/ruizzhao/diffusion_baseline/upstreams/candi/models/dit_cont.py:157: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(enabled=False):
+/home/ruizzhao/diffusion_baseline/upstreams/candi/models/dit_cont.py:112: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
+  with torch.cuda.amp.autocast(enabled=False):
+

results/logs/4gpu-benchmark-candi-lm1b-steps-2.out

@@ -0,0 +1,6 @@
+[2026-08-27 16:52:25,378][dlb_pinned_upstream_main][INFO] - Starting Sample Eval.
+Generative perplexity: 1988.3194580078125
+Sample entropy: 4.506678104400635
+Samples saved at: /home/ruizzhao/diffusion_baseline/results/conditional/samples/lm1b/candi/steps_2/upstream_samples.json
+{"status": "succeeded", "output": "/home/ruizzhao/diffusion_baseline/results/conditional/timing/lm1b/candi/steps_2/timing.json"}
+

results/logs/4gpu-benchmark-candi-owt-steps-32.err

@@ -0,0 +1,33 @@
+Traceback (most recent call last):
+  File "<frozen runpy>", line 198, in _run_module_as_main
+  File "<frozen runpy>", line 88, in _run_code
+  File "/home/ruizzhao/diffusion_baseline/src/dlb/benchmarking.py", line 495, in <module>
+    raise SystemExit(main())
+                     ^^^^^^
+  File "/home/ruizzhao/diffusion_baseline/src/dlb/benchmarking.py", line 479, in main
+    output = execute_one(
+             ^^^^^^^^^^^^
+  File "/home/ruizzhao/diffusion_baseline/src/dlb/benchmarking.py", line 402, in execute_one
+    resolved, adapter = _resolve_request(request, root, adapter)
+                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/home/ruizzhao/diffusion_baseline/src/dlb/runner.py", line 474, in _resolve_request
+    **_resolve_conditional_request(request, root),
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/home/ruizzhao/diffusion_baseline/src/dlb/runner.py", line 354, in _resolve_conditional_request
+    manifest = verify_prompts(root, request.dataset_id, protocol)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/home/ruizzhao/diffusion_baseline/src/dlb/conditional_prompts.py", line 341, in verify_prompts
+    dataset = load_from_disk(processed_path)
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/opt/anaconda3/envs/dlb-candi/lib/python3.11/site-packages/datasets/load.py", line 2687, in load_from_disk
+    fs, *_ = url_to_fs(dataset_path, **(storage_options or {}))
+             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/opt/anaconda3/envs/dlb-candi/lib/python3.11/site-packages/fsspec/core.py", line 383, in url_to_fs
+    chain = _un_chain(url, kwargs)
+            ^^^^^^^^^^^^^^^^^^^^^^
+  File "/opt/anaconda3/envs/dlb-candi/lib/python3.11/site-packages/fsspec/core.py", line 323, in _un_chain
+    if "::" in path
+       ^^^^^^^^^^^^
+TypeError: argument of type 'PosixPath' is not iterable
+
+ERROR conda.cli.main_run:execute(125): `conda run env PYTHONPATH=/home/ruizzhao/diffusion_baseline/src:/home/ruizzhao/diffusion_baseline/src:/home/ruizzhao/diffusion_baseline/src python -m dlb.benchmarking --root /home/ruizzhao/diffusion_baseline --models candi --datasets owt --steps 32 --seed 42 --precision author --generation-mode conditional_prefix` failed. (See above for error)