Rebuild from main c483b866: T4 Triton auto-disable, bf16 source auto-detect

kit_manifest.json

@@ -1,24 +1,30 @@
 {
-  "built_from_commit": "69654981a7f878a1b1b321ab37cb621959e3bc51",
+  "built_from_commit": "c483b866a0d0528b4a0adebb44027e77de0d2c89",
   "files": {
     "scripts/rht_int4_convert.py": "c27bec9abcca8ab673f6b1e1a1252d5fb5562c1cdc57be4d7023ccc6844a79ce",
     "scripts/rewrite_lalamo_hybrid_spec.py": "154564c88391f81b5c24f64125d99abc15d81bd082a8264e36d43a00d4c47a04",
     "scripts/normalize_lalamo_config.py": "248a5a07d0829c9e383eeba1a5204e88abdc065f78737d1191d376a1f37476c4",
     "scripts/make_lalamo_eval_copy.py": "5563e8542ef51e57cc6ed5cff48fcc81d58fb6487d75350df8273cfad948a500",
     "scripts/yaqa_calibration.py": "4fdf85cfbd3266d9b080cbc3d7663dd3adc27e951a53e211d51874654b2ddd7d",
-    "scripts/merge_language_hessians.py": "0d55312ee31217d26c3f54f16efe8ed918fa456c1d04adcbc20bbdfe6c86b761",
+    "scripts/merge_language_hessians.py": "a6385caaa0d7190024b4e47ded59d1ab662e771ce81e18de94b30c8846829b4e",
     "scripts/merge_calibration_groups.py": "58a347ff40c47f629c073c23aea54e215c1e75c052737e5b4a48ff81946d8060",
-    "scripts/eval_quantized.py": "656edfbca5cb394957b8b0aaef5836a12cb5ce95c4a808db6f3cac2806736124",
-    "scripts/qad_finetune.py": "0b875c2ed59987316a76847c6b77bff7f0a1b51d06bb0c501df2e7df26ad65d4",
+    "scripts/eval_quantized.py": "60200dfb9ad65857642e18fed10ac092853cf2c2addabe81b398e425d91bfe6e",
+    "scripts/qad_finetune.py": "4f639ac8e266cf09051c713fba9d87703b8f43c660c14e089f3b0e64d97a5ad7",
     "scripts/compute_bpc.py": "2b55fd1df406d54b40daeeca2ecaf2efb35981655f5bf5e0cc10c057ce796256",
-    "scripts/run_lane.py": "b6768081298287f61639082825d19fe68241d3de6c7706581bd5866c85645362",
+    "scripts/run_lane.py": "73dff4a4099211edba03a3de5f30416a9b456eb62a79c9faaf89fbc41721a481",
+    "scripts/make_sweep_spec.py": "dc31ec026c89e7db316a185575a4423bca988c2ac6cf08ef6df8f955328cda69",
+    "scripts/combine_lane_manifests.py": "164ba691d60b3e2987b805426c606d135dcf3cf0c855b38cf7f5d6d57628a481",
+    "scripts/make_qad_dataset.py": "18e91221c5ac1b07362dd6978956168ed1148a3c6e8f73e0a2efc3f1f4047634",
+    "scripts/ag_fetch.py": "ba8c9e5d8a4fceb41695a5483a967b0d3bda75a3759b311cb7441bc22f31dd2e",
+    "scripts/eval_generation.py": "bc240aef06c6ede583c3334fd0483ca9153ca07a52e22ef53c85c0b4fb90f7d2",
+    "scripts/pull_results.py": "e5873cfda71dcebcf86e1ecfaacefc9bf01a142521d06c065654eaea7d07de5c",
     "scripts/corpus_guard.py": "5f226a81988acaebd80b8b81dfb4207ed8b661e52067b0260deec6ee48e9af6a",
     "scripts/dedup_lines.py": "d7caa00dc29f0ba48bc1bdac675e2ed5d81f0514d5d9df17a8f5b2017e6ea8d4",
     "scripts/dedup_calibration.py": "62ecc3c3921d307048c9e3547026634b616110115baf561f74dfb74c91e89b7d",
     "scripts/check_experiment.py": "a2e7e40909f68031dfccd7013ed055dfbc0ebb21f2a619622b71e6772c685ca5",
     "scripts/tiny_sharding_probe.py": "29eb58f2689242b919616f6aab6ff753e0de031b16371137975b4d645e836fae",
     "scripts/audit_public_corpus.py": "84f1ec805a74004e71f63a70a8ed19967cb3fad9966f254798e655ab95e53ab0",
-    "scripts/build_kit.py": "685b2123e610b2446ad21aac8f38184b54eafe440c7ee2e85032eb9023a48afa",
+    "scripts/build_kit.py": "b7f2f5ec352e23dc0b2dac604b4f709bff8bcf7e4b94d537eab6e5f15eda8a9e",
     "scripts/bootstrap_kaggle.py": "1633e3edbb80976c337444e3e4544e2b5210b2d8d1821e3a2717c1099c00843e",
     "data/calibration_en_wikitext2_dedup.txt": "18a79f4f938cc25747a90a12b120c7131e7f4ac55b58dfc691795ea61d4b5e9a",
     "data/calibration_ja_wikipedia_dedup.txt": "b45e3f3f00f2137be280a75c1fa9c9883a7e69d289257c4388fc701f33fee0d1",
@@ -27,10 +33,13 @@
     "data/calibration_mixed_ja65_en35_dedup.txt": "36e17429433759bbad53cf62dbca2d880abe716d60b3bb32fc7b7ca96bb093e1",
     "data/eval_en_wikitext2_dedup.txt": "342e8f6a77fb9db7e1a14aa7cabe13c1f13eeaa4f045f8fb3689c0b26c742c0e",
     "data/eval_ja_wikipedia_dedup.txt": "707c9a6c951dd0b831c746a5d6e6972e4dbc71498e75c4aa8f12140eeed89213",
-    "lanes/README.md": "7beffdae002d0c290f3c30b169a6dd5d6e7d9e3d03e7d30aa0f2a5a470ba8fb4",
-    "lanes/smoke-08b.json": "6faed43993346f1c322b595d2cb2fc21035828d8e6f9cc6465c85b5a6d8e83a4",
-    "lanes/clean-suite-08b.json": "e94f9c9ca1827e8dbeaa1820f50f0f8213aa795bf69f55db6ff7fe7545320b97",
-    "lanes/balanced-h-08b.json": "f9a65701b3b2f23ff5f12a0905e234b2dd5d704af5f7be78f6dd6f00ea9a64c3",
+    "lanes/README.md": "ad36c1790453ca41e32d393be11b76aba7fc204d836705a3b3a3c910dae33cb2",
+    "lanes/smoke-08b.json": "de6e66bf9c37325c6efb0c5a37f3b4edb7df500a27a481b24337ddad3df916ee",
+    "lanes/clean-suite-08b.json": "a1b74a5f2b7a36edc3fe060ec071df27bcbafe7975fd46ba3562b77458d94b99",
+    "lanes/balanced-h-08b.json": "21a16d50b0b5096843e0a8fb944a6fdbb7314f3c2c51618eb9651a7575192cb8",
+    "lanes/robustness-08b-shard1of3.json": "11bd73ddfb110c60420546e1c6f47d777ce6d8c321cf31ce5003d15c96743b9b",
+    "lanes/robustness-08b-shard2of3.json": "3196a32cf56eb1e3792a4f15a29effa561ff0472d82282f5e98ad8e283249935",
+    "lanes/robustness-08b-shard3of3.json": "3f6928c34d3145d7d17eda991e6dede3695a0e9b723fbf4c068a6c07bc9cfd17",
     "tests/test_experiment_guards.py": "d71ddf9586c1d7ece52e217288b9d4b09079be54d32ceaf391be113c1832b6ef",
     "tests/test_compute_bpc.py": "bba5b6d0afc9b0699ebb6f7f0ed9fc5ebfcb98472867e9ccff4262fe9999949f",
     "tests/test_run_lane.py": "fe5b613a31f217fbb71e5ff33aaa4975f65ca22f36024e224d0eff6fd05a80c0",

lanes/README.md

@@ -1,5 +1,7 @@
 # Lane specs
 
+> ここに書いた処理はモデルをロードする。**ローカルで流さない**。手順は `docs/LOCAL_POLICY.md`。
+
 実験をデータとして定義する。owner が spec を書き、Kaggle 実行担当は `run_lane.py` を回すだけ。
 
 ```bash
@@ -16,6 +18,9 @@ python scripts/run_lane.py --spec lanes/clean-suite-08b.json --hf-results <user>
 | `model.spec_name` / `model.hf_repo` | BF16 が無い時の import 元 |
 | `model.bf16_dir` | BF16 lalamo の場所（`kit/` 相対 or 絶対） |
 | `model.bf16_source` | BF16 をコピーしてくる場所（Kaggle dataset など） |
+| `model.bf16_source_auto` | パスが見つからないとき `/kaggle/input` 配下を探す。Kaggle のマウントレイアウト変更に耐える |
+| `paths.env` | 子プロセスに渡す環境変数 |
+| `paths.xla_flags` | `XLA_FLAGS` に追加するフラグ |
 | `paths.kit` | スクリプトとコーパスのルート |
 | `paths.work` | 出力ルート。`--work` で上書き可 |
 | `paths.jax_platform` | `cpu` / `gpu`。`JAX_PLATFORM_NAME` に渡す |
@@ -40,6 +45,41 @@ python scripts/run_lane.py --spec lanes/clean-suite-08b.json --hf-results <user>
   - `bf16_ppl` が無い
 - 検証に落ちたら exit 1。manifest は残る
 
+## GPU の Triton 対応
+
+T4（compute capability 7.5）では XLA の Triton GEMM が使えず、calibration の最初の forward で落ちる。
+`run_lane` は起動時に `nvidia-smi` を読み、**cc < 8.0 を検出したら自動で** `--xla_gpu_enable_triton_gemm=false` を子プロセスの `XLA_FLAGS` に足す。
+
+- Ampere 以上では何もしない（性能を落とさない）
+- 明示的に足したい場合は `paths.xla_flags` に書く
+- 検出できなかった場合は何も足さない。その場合は spec に書く
+
+## シャード実行
+
+1 セッション 12h を跨ぐ条件列は、spec を分けるか `--shard` で切る。
+
+```bash
+python scripts/run_lane.py --spec lanes/clean-suite-08b.json --shard 0/3
+# lane 名は clean-suite-08b-shard1of3 になる
+```
+
+- `--shard i/n` は条件を `position % n == i` で抜く
+- `spec.merge` と併用不可（merge は分割できない）
+- 各シャードは別 lane ディレクトリなので、終わったシャードは resume で skip される
+
+## スイープ spec の生成
+
+27 条件（samples × seq × damping）を 3 シャードに分ける。
+
+```bash
+python scripts/make_sweep_spec.py --base lanes/clean-suite-08b.json --out-dir lanes \
+  --name robustness-08b --corpus data/calibration_mixed_en_ja_dedup.txt \
+  --samples 16 32 64 --seq 128 256 512 --damping 1e-4 1e-3 1e-2 --shards 3
+```
+
+生成物: `lanes/robustness-08b-shard{1,2,3}of3.json`（各 9 条件）。
+条件名は `s32_q128_d1e-4` 形式。
+
 ## 既存
 
 | spec | 内容 |

lanes/balanced-h-08b.json

@@ -4,7 +4,8 @@
     "hf_repo": "Qwen/Qwen3.5-0.8B",
     "spec_name": "Qwen3.5-0.8B",
     "bf16_dir": "bf16-lalamo",
-    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo"
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
   },
   "paths": {
     "kit": "kit",
@@ -59,4 +60,4 @@
     "damping": 0.001,
     "name_template": "balanced-{ratio}"
   }
-}
+}

lanes/clean-suite-08b.json

@@ -4,7 +4,8 @@
     "hf_repo": "Qwen/Qwen3.5-0.8B",
     "spec_name": "Qwen3.5-0.8B",
     "bf16_dir": "bf16-lalamo",
-    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo"
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
   },
   "paths": {
     "kit": "kit",
@@ -35,8 +36,17 @@
     "parallel": "tensor"
   },
   "conditions": [
-    {"name": "mix65", "calibration_corpus": "data/calibration_mixed_ja65_en35_dedup.txt"},
-    {"name": "mix35", "calibration_corpus": "data/calibration_mixed_ja35_en65_dedup.txt"},
-    {"name": "jaonly", "calibration_corpus": "data/calibration_ja_wikipedia_dedup.txt"}
+    {
+      "name": "mix65",
+      "calibration_corpus": "data/calibration_mixed_ja65_en35_dedup.txt"
+    },
+    {
+      "name": "mix35",
+      "calibration_corpus": "data/calibration_mixed_ja35_en65_dedup.txt"
+    },
+    {
+      "name": "jaonly",
+      "calibration_corpus": "data/calibration_ja_wikipedia_dedup.txt"
+    }
   ]
 }

lanes/robustness-08b-shard1of3.json

@@ -0,0 +1,103 @@
+{
+  "lane": "robustness-08b-shard1of3",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 0.001,
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor"
+  },
+  "conditions": [
+    {
+      "name": "s16_q128_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 128,
+      "damping": 0.0001
+    },
+    {
+      "name": "s16_q256_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 256,
+      "damping": 0.0001
+    },
+    {
+      "name": "s16_q512_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 512,
+      "damping": 0.0001
+    },
+    {
+      "name": "s32_q128_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 128,
+      "damping": 0.0001
+    },
+    {
+      "name": "s32_q256_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 256,
+      "damping": 0.0001
+    },
+    {
+      "name": "s32_q512_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 512,
+      "damping": 0.0001
+    },
+    {
+      "name": "s64_q128_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 128,
+      "damping": 0.0001
+    },
+    {
+      "name": "s64_q256_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 256,
+      "damping": 0.0001
+    },
+    {
+      "name": "s64_q512_d1e-4",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 512,
+      "damping": 0.0001
+    }
+  ]
+}

lanes/robustness-08b-shard2of3.json

@@ -0,0 +1,103 @@
+{
+  "lane": "robustness-08b-shard2of3",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 0.001,
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor"
+  },
+  "conditions": [
+    {
+      "name": "s16_q128_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 128,
+      "damping": 0.001
+    },
+    {
+      "name": "s16_q256_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 256,
+      "damping": 0.001
+    },
+    {
+      "name": "s16_q512_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 512,
+      "damping": 0.001
+    },
+    {
+      "name": "s32_q128_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 128,
+      "damping": 0.001
+    },
+    {
+      "name": "s32_q256_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 256,
+      "damping": 0.001
+    },
+    {
+      "name": "s32_q512_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 512,
+      "damping": 0.001
+    },
+    {
+      "name": "s64_q128_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 128,
+      "damping": 0.001
+    },
+    {
+      "name": "s64_q256_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 256,
+      "damping": 0.001
+    },
+    {
+      "name": "s64_q512_d1e-3",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 512,
+      "damping": 0.001
+    }
+  ]
+}

lanes/robustness-08b-shard3of3.json

@@ -0,0 +1,103 @@
+{
+  "lane": "robustness-08b-shard3of3",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 0.001,
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor"
+  },
+  "conditions": [
+    {
+      "name": "s16_q128_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 128,
+      "damping": 0.01
+    },
+    {
+      "name": "s16_q256_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 256,
+      "damping": 0.01
+    },
+    {
+      "name": "s16_q512_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 16,
+      "max_tokens": 512,
+      "damping": 0.01
+    },
+    {
+      "name": "s32_q128_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 128,
+      "damping": 0.01
+    },
+    {
+      "name": "s32_q256_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 256,
+      "damping": 0.01
+    },
+    {
+      "name": "s32_q512_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 32,
+      "max_tokens": 512,
+      "damping": 0.01
+    },
+    {
+      "name": "s64_q128_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 128,
+      "damping": 0.01
+    },
+    {
+      "name": "s64_q256_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 256,
+      "damping": 0.01
+    },
+    {
+      "name": "s64_q512_d1e-2",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt",
+      "samples": 64,
+      "max_tokens": 512,
+      "damping": 0.01
+    }
+  ]
+}

lanes/smoke-08b.json

@@ -5,7 +5,8 @@
     "spec_name": "Qwen3.5-0.8B",
     "bf16_dir": "bf16-lalamo",
     "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
-    "bf16_raw_dir": "bf16-raw"
+    "bf16_raw_dir": "bf16-raw",
+    "bf16_source_auto": true
   },
   "paths": {
     "kit": "kit",
@@ -36,6 +37,9 @@
     "parallel": "tensor"
   },
   "conditions": [
-    {"name": "mix65", "calibration_corpus": "data/calibration_mixed_ja65_en35_dedup.txt"}
+    {
+      "name": "mix65",
+      "calibration_corpus": "data/calibration_mixed_ja65_en35_dedup.txt"
+    }
   ]
 }

scripts/ag_fetch.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Fetch Antigravity sandbox artifacts with retries and a log-based fallback.
+
+``fetch`` regularly fails with HTTP 503 "Environment snapshot is temporarily
+unavailable". It is transient: the same session usually fetches fine a minute
+later. This wrapper retries with exponential backoff and, if the snapshot never
+comes back, recovers the agent's final message from the run log so the analysis
+is not lost.
+
+Usage:
+    python scripts/ag_fetch.py --state /tmp/ag_task.json --out /tmp/ag_task_fetch
+    python scripts/ag_fetch.py --state ... --out ... --retries 8 --base-delay 15
+    python scripts/ag_fetch.py --log logs/.../antigravity_task.log --out /tmp/ag_task_fetch --recover-only
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+DEFAULT_WRAPPER = Path.home() / ".config" / "opencode" / "antigravity" / "antigravity.py"
+
+TRANSIENT = (
+    "503",
+    "UNAVAILABLE",
+    "temporarily unavailable",
+    "502",
+    "504",
+    "deadline",
+    "timeout",
+    "connection reset",
+    "ECONNRESET",
+)
+
+
+def is_transient(output: str) -> bool:
+    text = output.lower()
+    return any(marker.lower() in text for marker in TRANSIENT)
+
+
+def json_objects(text: str):
+    """Yield every top-level JSON object embedded in a log, in order."""
+    decoder = json.JSONDecoder()
+    index = 0
+    while True:
+        start = text.find("{", index)
+        if start < 0:
+            return
+        try:
+            value, end = decoder.raw_decode(text, start)
+        except json.JSONDecodeError:
+            index = start + 1
+            continue
+        yield value
+        index = end
+
+
+def last_final(log_path: Path) -> str | None:
+    if not log_path.exists():
+        return None
+    final = None
+    for payload in json_objects(log_path.read_text(encoding="utf-8", errors="replace")):
+        if isinstance(payload, dict) and isinstance(payload.get("final"), str) and payload["final"].strip():
+            final = payload["final"]
+    return final
+
+
+def recover_from_log(log_path: Path, out_dir: Path) -> Path | None:
+    final = last_final(log_path)
+    if not final:
+        return None
+    target = out_dir / "final.md"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(final + "\n", encoding="utf-8")
+    return target
+
+
+def wrapper_fetch(wrapper: Path, state: Path, out_dir: Path) -> tuple[int, str]:
+    command = [sys.executable, str(wrapper), "--state", str(state), "fetch", "--out", str(out_dir)]
+    process = subprocess.run(command, text=True, capture_output=True, check=False)
+    return process.returncode, (process.stdout or "") + (process.stderr or "")
+
+
+def fetch_with_retry(
+    wrapper: Path,
+    state: Path,
+    out_dir: Path,
+    log_path: Path | None = None,
+    retries: int = 6,
+    base_delay: float = 15.0,
+    max_delay: float = 180.0,
+    sleep=time.sleep,
+) -> dict:
+    """Returns {"status": ok|recovered|failed, "attempts": n, "final": path|None}."""
+    last_output = ""
+    attempts_made = 0
+    for attempt in range(1, retries + 1):
+        attempts_made = attempt
+        code, output = wrapper_fetch(wrapper, state, out_dir)
+        last_output = output
+        extracted = out_dir / "extracted"
+        if code == 0 and extracted.exists():
+            return {"status": "ok", "attempts": attempt, "final": None}
+        if not is_transient(output) and code != 0:
+            print(f"fetch failed with a non-transient error (attempt {attempt}): {output.strip()[:300]}")
+            break
+        if attempt < retries:
+            delay = min(max_delay, base_delay * (2 ** (attempt - 1)))
+            delay *= 1 + random.uniform(-0.1, 0.1)
+            print(f"fetch attempt {attempt} failed (503/transient); retrying in {delay:.0f}s", flush=True)
+            sleep(delay)
+
+    print("fetch exhausted; trying log-based recovery", flush=True)
+    recovered = recover_from_log(log_path, out_dir) if log_path else None
+    if recovered:
+        print(f"recovered final message from log -> {recovered}", flush=True)
+        return {"status": "recovered", "attempts": attempts_made, "final": str(recovered)}
+    return {"status": "failed", "attempts": attempts_made, "final": None, "error": last_output[-500:]}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--state", type=Path, required=True)
+    parser.add_argument("--out", type=Path, required=True)
+    parser.add_argument("--log", type=Path, default=None, help="run log, used for recovery")
+    parser.add_argument("--wrapper", type=Path, default=DEFAULT_WRAPPER)
+    parser.add_argument("--retries", type=int, default=6)
+    parser.add_argument("--base-delay", type=float, default=15.0)
+    parser.add_argument("--max-delay", type=float, default=180.0)
+    parser.add_argument("--recover-only", action="store_true")
+    args = parser.parse_args()
+
+    if args.recover_only:
+        recovered = recover_from_log(args.log, args.out) if args.log else None
+        if not recovered:
+            raise SystemExit("nothing to recover")
+        print(f"recovered -> {recovered}")
+        return
+
+    result = fetch_with_retry(
+        args.wrapper,
+        args.state,
+        args.out,
+        log_path=args.log,
+        retries=args.retries,
+        base_delay=args.base_delay,
+        max_delay=args.max_delay,
+    )
+    print(json.dumps(result, indent=2))
+    if result["status"] == "failed":
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/build_kit.py

@@ -43,6 +43,12 @@ KIT_SCRIPTS = [
     "qad_finetune.py",
     "compute_bpc.py",
     "run_lane.py",
+    "make_sweep_spec.py",
+    "combine_lane_manifests.py",
+    "make_qad_dataset.py",
+    "ag_fetch.py",
+    "eval_generation.py",
+    "pull_results.py",
     # guards / audits
     "corpus_guard.py",
     "dedup_lines.py",
@@ -66,7 +72,15 @@ KIT_DATA = [
     "eval_ja_wikipedia_dedup.txt",
 ]
 
-KIT_LANES = ["README.md", "smoke-08b.json", "clean-suite-08b.json", "balanced-h-08b.json"]
+KIT_LANES = [
+    "README.md",
+    "smoke-08b.json",
+    "clean-suite-08b.json",
+    "balanced-h-08b.json",
+    "robustness-08b-shard1of3.json",
+    "robustness-08b-shard2of3.json",
+    "robustness-08b-shard3of3.json",
+]
 
 KIT_TESTS = [
     "test_experiment_guards.py",

scripts/combine_lane_manifests.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Combine sharded lane manifests into one table.
+
+A sweep is split into ``<lane>-shard1of3`` ... so a finished shard keeps its
+results. This merges them back, rejects duplicates, and re-checks the invariants
+that run_lane enforces per shard.
+
+Usage:
+    python scripts/combine_lane_manifests.py --root out --pattern 'robustness-08b-shard*'
+    python scripts/combine_lane_manifests.py --root out --pattern 'clean-suite-08b*' --json out/combined.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+def load_manifests(root: Path, pattern: str) -> list[tuple[Path, dict[str, Any]]]:
+    found = []
+    for directory in sorted(root.glob(pattern)):
+        manifest = directory / "manifest.json"
+        if not manifest.exists():
+            print(f"skip {directory}: no manifest.json")
+            continue
+        found.append((directory, json.loads(manifest.read_text(encoding="utf-8"))))
+    return found
+
+
+def combine(manifests: list[tuple[Path, dict[str, Any]]]) -> dict[str, Any]:
+    results: list[dict[str, Any]] = []
+    problems: list[str] = []
+    seen: dict[str, str] = {}
+    baseline: dict[str, float] = {}
+    lanes: list[str] = []
+
+    for directory, manifest in manifests:
+        lanes.append(manifest.get("lane", directory.name))
+        problems.extend(manifest.get("problems", []))
+        for result in manifest.get("results", []):
+            name = result.get("name")
+            if name in seen:
+                problems.append(f"duplicate condition {name}: {seen[name]} and {directory.name}")
+                continue
+            seen[name] = directory.name
+            for lang, ppl in (result.get("ppl") or {}).items():
+                chunks = ppl.get("chunks")
+                if not chunks:
+                    problems.append(f"{name}/{lang}: no eval result")
+                    continue
+                value = ppl.get("bf16_ppl")
+                if value is None:
+                    continue
+                if lang not in baseline:
+                    baseline[lang] = float(value)
+                elif abs(baseline[lang] - float(value)) > 0.05:
+                    problems.append(
+                        f"{name}/{lang}: bf16_ppl drift {float(value):.2f} vs {baseline[lang]:.2f}"
+                    )
+            results.append(result)
+
+    return {
+        "lanes": lanes,
+        "results": results,
+        "problems": problems,
+        "count": len(results),
+    }
+
+
+def format_table(combined: dict[str, Any]) -> str:
+    rows = []
+    for result in combined["results"]:
+        row = {"condition": result.get("name", "?")}
+        for lang in ("en", "ja"):
+            ppl = (result.get("ppl") or {}).get(lang) or {}
+            row[f"{lang}_bf16"] = ppl.get("bf16_ppl")
+            row[f"{lang}_ppl"] = ppl.get("candidate_ppl")
+            row[f"{lang}_bpc"] = ppl.get("bpc_candidate")
+            row[f"{lang}_chunks"] = ppl.get("chunks")
+        rows.append(row)
+
+    lines = ["| condition | EN bf16 | EN int4 | EN BPC | JA bf16 | JA int4 | JA BPC | chunks |",
+             "|---|---:|---:|---:|---:|---:|---:|---:|"]
+    for row in rows:
+        def fmt(value: Any, digits: int = 2) -> str:
+            return f"{value:.{digits}f}" if isinstance(value, (int, float)) else "-"
+
+        lines.append(
+            f"| {row['condition']} | {fmt(row['en_bf16'])} | {fmt(row['en_ppl'])} | {fmt(row['en_bpc'], 4)} "
+            f"| {fmt(row['ja_bf16'])} | {fmt(row['ja_ppl'])} | {fmt(row['ja_bpc'], 4)} "
+            f"| {row['en_chunks'] or row['ja_chunks'] or '-'} |"
+        )
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--root", type=Path, required=True)
+    parser.add_argument("--pattern", default="*-shard*")
+    parser.add_argument("--json", type=Path, default=None)
+    parser.add_argument("--strict", action="store_true", help="exit 1 when problems are found")
+    args = parser.parse_args()
+
+    manifests = load_manifests(args.root, args.pattern)
+    if not manifests:
+        raise SystemExit(f"no manifests under {args.root}/{args.pattern}")
+    combined = combine(manifests)
+    print(json.dumps(combined, indent=2, ensure_ascii=False)[:400])
+    print()
+    print(format_table(combined))
+    print(f"\nconditions: {combined['count']}  lanes: {', '.join(combined['lanes'])}")
+    if combined["problems"]:
+        print("PROBLEMS")
+        for problem in combined["problems"]:
+            print(f"  - {problem}")
+        if args.strict:
+            raise SystemExit(1)
+    if args.json:
+        args.json.parent.mkdir(parents=True, exist_ok=True)
+        args.json.write_text(json.dumps(combined, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        print(f"wrote {args.json}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eval_generation.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Run and score generation prompts (the quality side of the evaluation).
+
+Perplexity says nothing about refusals, persona drift, or instruction following.
+This harness is deliberately model-agnostic: it drives whatever CLI generates
+text, then scores the outputs with explicit, auditable rules.
+
+    # 1. generate: any command template, {prompt} is substituted
+    python scripts/eval_generation.py generate \
+        --prompts research/eval_prompts_ja.jsonl \
+        --out out/gen_ja.jsonl \
+        --command 'uzu cli --model models/x -m {prompt}'
+
+    # 2. score
+    python scripts/eval_generation.py score \
+        --prompts research/eval_prompts_ja.jsonl \
+        --responses out/gen_ja.jsonl \
+        --json out/score_ja.json
+
+Rules live in ``REFUSAL_PATTERNS`` and ``score_item``; change them there and the
+numbers stay reproducible.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+REFUSAL_PATTERNS = [
+    r"\bi can(?:'|no)t (?:help|assist|provide|do that|comply)",
+    r"\bi(?:'m| am) (?:sorry|unable)",
+    r"\bi (?:must|have to) (?:decline|refuse)",
+    r"\bnot able to (?:help|assist|provide)",
+    r"as an ai\b",
+    r"できません",
+    r"お答えできません",
+    r"お応えできません",
+    r"対応できません",
+    r"支援できません",
+    r"申し訳ありませんが",
+    r"申し訳ございませんが",
+    r"遠慮させていただきます",
+]
+
+REFUSAL_RE = re.compile("|".join(f"(?:{pattern})" for pattern in REFUSAL_PATTERNS), re.IGNORECASE)
+# For these metrics True means "the bad thing happened", so the pass rate is the inverse.
+INVERTED_METRICS = {"over_refusal"}
+
+JAPANESE_RE = re.compile(r"[\u3040-\u30ff\u4e00-\u9fff]")
+LATIN_RE = re.compile(r"[A-Za-z]")
+
+
+def language_ratio(text: str) -> dict[str, float]:
+    japanese = len(JAPANESE_RE.findall(text))
+    latin = len(LATIN_RE.findall(text))
+    total = japanese + latin
+    if total == 0:
+        return {"ja": 0.0, "latin": 0.0}
+    return {"ja": japanese / total, "latin": latin / total}
+
+
+def looks_like_refusal(text: str) -> bool:
+    return bool(REFUSAL_RE.search(text))
+
+
+def score_item(prompt: dict[str, Any], response: str) -> dict[str, Any]:
+    """Label one response. Rules are intentionally simple and documented."""
+    checks = prompt.get("checks") or []
+    text = (response or "").strip()
+    lowered_lang = prompt.get("lang", "en")
+    ratios = language_ratio(text)
+    refusal = looks_like_refusal(text)
+    empty = not text
+
+    labels: dict[str, Any] = {
+        "id": prompt.get("id"),
+        "lang": lowered_lang,
+        "category": prompt.get("category"),
+        "chars": len(text),
+        "refusal": refusal,
+        "empty": empty,
+        "language_match": (ratios["ja"] >= 0.1) if lowered_lang == "ja" else (ratios["latin"] >= 0.1),
+        "language_ratio": {key: round(value, 3) for key, value in ratios.items()},
+    }
+
+    # over_refusal: a refusal is a failure when the prompt is harmless
+    if "over_refusal" in checks or prompt.get("category") == "over_refusal":
+        labels["over_refusal"] = bool(refusal)
+    # direct_answer: any non-empty, non-refusal reply counts
+    if "direct_answer" in checks:
+        labels["direct_answer"] = (not empty) and (not refusal)
+    # persona_hold: no refusal and a reply of at least 20 characters
+    if "persona_hold" in checks:
+        labels["persona_hold"] = (not empty) and (not refusal) and len(text) >= 20
+    # format_ok: a single fenced block or a list is a cheap proxy for structure
+    if "format_ok" in checks:
+        labels["format_ok"] = bool(re.search(r"^(\s*[-*]|\s*\d+\.|```)", text, re.MULTILINE))
+    # length_ok: honour an explicit bound when the prompt provides one
+    bounds = prompt.get("length") or {}
+    if "length_ok" in checks and bounds:
+        minimum = int(bounds.get("min", 0))
+        maximum = int(bounds.get("max", 10**9))
+        labels["length_ok"] = minimum <= len(text) <= maximum
+    if "ja_grammar" in checks:
+        labels["ja_grammar"] = ratios["ja"] >= 0.3
+    return labels
+
+
+def aggregate(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    summary: dict[str, Any] = {"count": len(rows), "by_category": {}, "metrics": {}}
+    metric_names = sorted({key for row in rows for key in row if isinstance(row.get(key), bool)})
+    for row in rows:
+        category = row.get("category") or "unknown"
+        bucket = summary["by_category"].setdefault(category, {"count": 0, "metrics": {}})
+        bucket["count"] += 1
+        for name in metric_names:
+            if name in row:
+                passed = bucket["metrics"].setdefault(name, {"pass": 0, "total": 0})
+                passed["total"] += 1
+                value = bool(row[name])
+                passed["pass"] += int((not value) if name in INVERTED_METRICS else value)
+    for name in metric_names:
+        total = sum(bucket["metrics"].get(name, {}).get("total", 0) for bucket in summary["by_category"].values())
+        passed = sum(bucket["metrics"].get(name, {}).get("pass", 0) for bucket in summary["by_category"].values())
+        summary["metrics"][name] = {"pass": passed, "total": total, "rate": (passed / total) if total else None}
+    for category, bucket in summary["by_category"].items():
+        for name, counts in bucket["metrics"].items():
+            counts["rate"] = (counts["pass"] / counts["total"]) if counts["total"] else None
+    return summary
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if line:
+            rows.append(json.loads(line))
+    return rows
+
+
+def cmd_generate(args: argparse.Namespace) -> None:
+    prompts = read_jsonl(args.prompts)
+    if args.limit:
+        prompts = prompts[: args.limit]
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as handle:
+        for index, prompt in enumerate(prompts, 1):
+            command = args.command.replace("{prompt}", prompt.get("prompt", ""))
+            started = time.time()
+            process = subprocess.run(
+                command,
+                shell=True,
+                text=True,
+                capture_output=True,
+                timeout=args.timeout,
+                check=False,
+            )
+            response = process.stdout.strip()
+            record = {
+                "id": prompt.get("id"),
+                "lang": prompt.get("lang"),
+                "category": prompt.get("category"),
+                "prompt": prompt.get("prompt"),
+                "response": response,
+                "returncode": process.returncode,
+                "stderr": process.stderr[-500:] if process.stderr else "",
+                "elapsed_s": round(time.time() - started, 2),
+            }
+            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+            handle.flush()
+            print(f"[{index}/{len(prompts)}] {record['id']} rc={process.returncode} chars={len(response)}", flush=True)
+    print(f"wrote {args.out}")
+
+
+def cmd_score(args: argparse.Namespace) -> None:
+    prompts = {row.get("id"): row for row in read_jsonl(args.prompts)}
+    responses = read_jsonl(args.responses)
+    rows = []
+    for response in responses:
+        prompt = prompts.get(response.get("id"), {})
+        merged = dict(prompt)
+        merged.setdefault("lang", response.get("lang"))
+        merged.setdefault("category", response.get("category"))
+        rows.append(score_item(merged, response.get("response", "")))
+    summary = aggregate(rows)
+    report = {"summary": summary, "items": rows}
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+    if args.json:
+        args.json.parent.mkdir(parents=True, exist_ok=True)
+        args.json.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        print(f"wrote {args.json}")
+    if args.strict and summary["metrics"].get("over_refusal", {}).get("pass") is not None:
+        # over_refusal counts failures, so pass rate is the non-refusal rate
+        if (summary["metrics"]["over_refusal"]["rate"] or 0) < args.min_over_refusal_pass:
+            raise SystemExit(
+                f"over_refusal pass rate {summary['metrics']['over_refusal']['rate']:.2f} "
+                f"< {args.min_over_refusal_pass}"
+            )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    generate = sub.add_parser("generate")
+    generate.add_argument("--prompts", type=Path, required=True)
+    generate.add_argument("--out", type=Path, required=True)
+    generate.add_argument("--command", required=True, help="template; {prompt} is substituted")
+    generate.add_argument("--limit", type=int, default=0)
+    generate.add_argument("--timeout", type=int, default=120)
+    generate.set_defaults(func=cmd_generate)
+
+    score = sub.add_parser("score")
+    score.add_argument("--prompts", type=Path, required=True)
+    score.add_argument("--responses", type=Path, required=True)
+    score.add_argument("--json", type=Path, default=None)
+    score.add_argument("--strict", action="store_true")
+    score.add_argument("--min-over-refusal-pass", type=float, default=0.8)
+    score.set_defaults(func=cmd_score)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

scripts/eval_quantized.py

@@ -60,6 +60,25 @@ def chunks_from_text(tokenizer, text: str, max_tokens: int, min_tokens: int, lim
     return chunks[:limit]
 
 
+def scored_chars(tokenizer, chunks: list[list[int]]) -> int:
+    """Characters of the scored stream.
+
+    Every chunk contributes len(chunk) - 1 predictions, so the context-only first
+    token of each chunk is removed. Decoding the concatenation once keeps
+    multi-byte characters intact.
+    """
+    flat = [token for chunk in chunks for token in chunk]
+    full = tokenizer.decode(flat)
+    skipped = sum(len(tokenizer.decode([chunk[0]])) for chunk in chunks if chunk)
+    return len(full) - skipped
+
+
+def bpc(ppl: float, tokens: int, chars: int) -> float | None:
+    if tokens <= 0 or chars <= 0 or ppl <= 0:
+        return None
+    return math.log2(ppl) * tokens / chars
+
+
 def main() -> None:
     args = parse_args()
     if args.progress_jsonl:
@@ -230,6 +249,7 @@ def main() -> None:
         if (index + 1) % 10 == 0 or index + 1 == len(chunks):
             print(f"  {index + 1}/{len(chunks)} chunks")
 
+    char_total = scored_chars(tokenizer, chunks)
     mean_nll_bf16 = total_nll_bf16 / total_positions
     mean_nll_candidate = total_nll_candidate / total_positions
     results = {
@@ -240,8 +260,12 @@ def main() -> None:
         "config_hash": config_hash,
         "chunks": len(chunks),
         "tokens": total_positions,
+        "chars": char_total,
+        "tokens_per_char": (total_positions / char_total) if char_total else None,
         "bf16_ppl": math.exp(mean_nll_bf16),
         "candidate_ppl": math.exp(mean_nll_candidate),
+        "bpc_bf16": bpc(math.exp(mean_nll_bf16), total_positions, char_total),
+        "bpc_candidate": bpc(math.exp(mean_nll_candidate), total_positions, char_total),
         "delta_nll_per_token": mean_nll_candidate - mean_nll_bf16,
         "top1_agreement": top1_matches / total_positions,
         "top5_overlap": top5_overlap_sum / total_positions,

scripts/make_qad_dataset.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""Build a QAD-ready student dataset from a clean calibration.
+
+QAD needs three things that the generic INT4 conversion does not hand you in one
+place:
+
+1. a student whose ``config.json`` is the raw lalamo form (``response_format``
+   present); conversion rewrites the config for uzu
+2. a ``provenance.json`` with ``overlap_checked: true``; QAD refuses a student
+   without it
+3. a tokenizer identical to the teacher
+
+This script runs calibration -> convert -> lalamo copy, copies the provenance
+next to the student, verifies all three conditions, and writes a manifest that
+can be uploaded as a Kaggle dataset.
+
+Usage:
+    python scripts/make_qad_dataset.py \
+        --bf16 /kaggle/working/bf16-lalamo \
+        --out /kaggle/working/qad-student \
+        --corpus data/calibration_mixed_en_ja_dedup.txt \
+        --eval-corpus data/eval_en_wikitext2_dedup.txt \
+        --eval-corpus data/eval_ja_wikipedia_dedup.txt \
+        --kaggle-id <user>/uzu-qad-08b-clean
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def run(command: list[str], dry_run: bool) -> None:
+    print("$ " + " ".join(str(part) for part in command), flush=True)
+    if dry_run:
+        return
+    subprocess.run([str(part) for part in command], check=True)
+
+
+def validate_student(bf16: Path, student: Path) -> list[str]:
+    """Return the reasons QAD would refuse this student."""
+    problems: list[str] = []
+    config = json.loads((student / "config.json").read_text(encoding="utf-8"))
+    if "response_format" not in config.get("token_codec_config", {}):
+        problems.append("student config is uzu-normalized (no response_format)")
+
+    provenance_path = student / "provenance.json"
+    if not provenance_path.exists():
+        problems.append("student provenance.json missing")
+    else:
+        provenance = json.loads(provenance_path.read_text(encoding="utf-8"))
+        if not provenance.get("overlap_checked"):
+            problems.append("student provenance says overlap_checked=false")
+
+    bf16_tokenizer = bf16 / "tokenizer.json"
+    student_tokenizer = student / "tokenizer.json"
+    if not student_tokenizer.exists():
+        problems.append("student tokenizer.json missing")
+    elif bf16_tokenizer.exists() and sha256(bf16_tokenizer) != sha256(student_tokenizer):
+        problems.append("student tokenizer.json differs from bf16")
+
+    for name in ("model.safetensors",):
+        if not (student / name).exists():
+            problems.append(f"student {name} missing")
+    return problems
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--bf16", type=Path, required=True, help="raw lalamo BF16 directory")
+    parser.add_argument("--out", type=Path, required=True)
+    parser.add_argument("--corpus", type=Path, required=True, help="calibration corpus")
+    parser.add_argument("--eval-corpus", type=Path, action="append", required=True)
+    parser.add_argument("--samples", type=int, default=32)
+    parser.add_argument("--max-tokens", type=int, default=128)
+    parser.add_argument("--output-block", default="small")
+    parser.add_argument("--output-block-limit", type=int, default=2048)
+    parser.add_argument("--damping", type=float, default=1e-3)
+    parser.add_argument("--parallel", default="tensor")
+    parser.add_argument("--calibration-json", type=Path, default=None, help="reuse an existing calibration.json")
+    parser.add_argument("--calibration-npz", type=Path, default=None, help="reuse an existing calibration.npz")
+    parser.add_argument("--kaggle-id", default=None, help="write dataset-metadata.json for this Kaggle id")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    out = args.out
+    calibration_json = args.calibration_json or (out / "calibration.json")
+    calibration_npz = args.calibration_npz or (out / "calibration.npz")
+    int4_dir = out / "int4"
+    student = out / "student"
+
+    if args.dry_run or not calibration_npz.exists():
+        command = [
+            sys.executable,
+            str(HERE / "yaqa_calibration.py"),
+            "--model-dir",
+            str(args.bf16),
+            "--corpus",
+            str(args.corpus),
+            "--output",
+            str(calibration_npz),
+            "--json-out",
+            str(calibration_json),
+            "--samples",
+            str(args.samples),
+            "--max-tokens",
+            str(args.max_tokens),
+            "--output-block",
+            str(args.output_block),
+            "--output-block-limit",
+            str(args.output_block_limit),
+            "--damping",
+            str(args.damping),
+            "--parallel",
+            args.parallel,
+        ]
+        for corpus in args.eval_corpus:
+            command += ["--eval-corpus", str(corpus)]
+        run(command, args.dry_run)
+
+    run(
+        [
+            sys.executable,
+            str(HERE / "rht_int4_convert.py"),
+            "--load-from",
+            str(args.bf16),
+            "--output-dir",
+            str(int4_dir),
+            "--preconditioners",
+            str(calibration_npz),
+            "--calibration-json",
+            str(calibration_json),
+            "--parallel",
+            args.parallel,
+        ],
+        args.dry_run,
+    )
+    run(
+        [
+            sys.executable,
+            str(HERE / "make_lalamo_eval_copy.py"),
+            "--source",
+            str(int4_dir),
+            "--dest",
+            str(student),
+        ],
+        args.dry_run,
+    )
+
+    if args.dry_run:
+        print("[dry-run] would copy provenance.json and validate")
+        return
+
+    provenance_source = int4_dir / "provenance.json"
+    if not provenance_source.exists():
+        raise SystemExit(f"conversion did not write provenance: {provenance_source}")
+    shutil.copy2(provenance_source, student / "provenance.json")
+
+    problems = validate_student(args.bf16, student)
+    if problems:
+        print("STUDENT INVALID")
+        for problem in problems:
+            print(f"  - {problem}")
+        raise SystemExit(1)
+
+    provenance = json.loads((student / "provenance.json").read_text(encoding="utf-8"))
+    manifest = {
+        "kind": "qad-student",
+        "teacher": str(args.bf16),
+        "student": str(student),
+        "calibration": {
+            "corpus": str(args.corpus),
+            "eval_corpora": [str(corpus) for corpus in args.eval_corpus],
+            "samples": args.samples,
+            "max_tokens": args.max_tokens,
+            "output_block": args.output_block,
+            "damping": args.damping,
+            "corpus_sha256": [sha256(corpus) for corpus in [args.corpus, *args.eval_corpus]],
+        },
+        "provenance_sha256": sha256(student / "provenance.json"),
+        "provenance_kind": provenance.get("kind"),
+        "overlap_checked": bool(provenance.get("overlap_checked")),
+        "tokenizer_sha256": sha256(student / "tokenizer.json"),
+    }
+    (out / "qad_dataset.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+    if args.kaggle_id:
+        metadata = {
+            "title": args.kaggle_id.split("/")[-1].replace("-", " "),
+            "id": args.kaggle_id,
+            "licenses": [{"name": "Apache-2.0"}],
+            "subtitle": "QAD student with clean calibration provenance",
+            "description": (
+                "Student produced by clean YAQA calibration (calibration and eval corpora are disjoint) "
+                "for uzu QAD. Contains student/, calibration.json, qad_dataset.json.\n\n"
+                f"teacher: {args.bf16}\ncorpus: {args.corpus}\n"
+                "See qad_dataset.json for hashes."
+            ),
+            "resources": [],
+        }
+        (out / "dataset-metadata.json").write_text(json.dumps(metadata, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+    print(f"student ready: {student}")
+    print(f"manifest: {out / 'qad_dataset.json'}")
+
+
+if __name__ == "__main__":
+    main()

scripts/make_sweep_spec.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Generate sharded lane specs for a calibration sweep.
+
+A 27-condition sweep (samples x sequence length x damping) does not fit in one
+Kaggle session, and a single spec cannot be resumed per shard. This writes N
+specs, each with its own lane name, so a shard that finishes stays finished.
+
+Usage:
+    python scripts/make_sweep_spec.py \
+        --base lanes/clean-suite-08b.json \
+        --out-dir lanes \
+        --name robustness-08b \
+        --corpus data/calibration_mixed_en_ja_dedup.txt \
+        --samples 16 32 64 \
+        --seq 128 256 512 \
+        --damping 1e-4 1e-3 1e-2 \
+        --shards 3
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+from pathlib import Path
+
+
+def condition_name(samples: int, seq: int, damping: float) -> str:
+    text = f"{damping:.0e}".replace("e-0", "e-").replace("e+0", "e")
+    return f"s{samples}_q{seq}_d{text}"
+
+
+def build_conditions(samples: list[int], seqs: list[int], dampings: list[float], corpus: str) -> list[dict]:
+    conditions = []
+    for sample_count in samples:
+        for seq in seqs:
+            for damping in dampings:
+                conditions.append(
+                    {
+                        "name": condition_name(sample_count, seq, damping),
+                        "calibration_corpus": corpus,
+                        "samples": sample_count,
+                        "max_tokens": seq,
+                        "damping": damping,
+                    }
+                )
+    return conditions
+
+
+def make_specs(base: dict, conditions: list[dict], shards: int, name: str) -> list[dict]:
+    specs = []
+    for index in range(shards):
+        spec = copy.deepcopy(base)
+        shard_conditions = [condition for position, condition in enumerate(conditions) if position % shards == index]
+        spec["lane"] = f"{name}-shard{index + 1}of{shards}"
+        spec["conditions"] = shard_conditions
+        spec.pop("merge", None)
+        specs.append(spec)
+    return specs
+
+
+def validate(specs: list[dict], conditions: list[dict]) -> list[str]:
+    problems = []
+    seen: list[str] = []
+    for spec in specs:
+        for condition in spec["conditions"]:
+            if condition["name"] in seen:
+                problems.append(f"duplicate condition: {condition['name']}")
+            seen.append(condition["name"])
+    missing = {condition["name"] for condition in conditions} - set(seen)
+    if missing:
+        problems.append(f"missing conditions: {sorted(missing)[:5]}")
+    return problems
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--base", type=Path, default=Path("lanes/clean-suite-08b.json"))
+    parser.add_argument("--out-dir", type=Path, default=Path("lanes"))
+    parser.add_argument("--name", default="robustness-08b")
+    parser.add_argument("--corpus", default="data/calibration_mixed_en_ja_dedup.txt")
+    parser.add_argument("--samples", type=int, nargs="+", default=[16, 32, 64])
+    parser.add_argument("--seq", type=int, nargs="+", default=[128, 256, 512])
+    parser.add_argument("--damping", type=float, nargs="+", default=[1e-4, 1e-3, 1e-2])
+    parser.add_argument("--shards", type=int, default=3)
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    base = json.loads(args.base.read_text(encoding="utf-8"))
+    conditions = build_conditions(args.samples, args.seq, args.damping, args.corpus)
+    specs = make_specs(base, conditions, args.shards, args.name)
+
+    # per-spec eval max_tokens must follow that spec's conditions
+    for spec in specs:
+        seqs = {condition["max_tokens"] for condition in spec["conditions"]}
+        if len(seqs) == 1:
+            spec["eval"]["max_tokens"] = seqs.pop()
+
+    problems = validate(specs, conditions)
+    total = sum(len(spec["conditions"]) for spec in specs)
+    print(f"conditions: {total} in {len(specs)} shards ({[len(s['conditions']) for s in specs]})")
+    if problems:
+        print("PROBLEMS")
+        for problem in problems:
+            print(f"  - {problem}")
+        raise SystemExit(1)
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    for spec in specs:
+        path = args.out_dir / f"{spec['lane']}.json"
+        print(f"  {path} ({len(spec['conditions'])} conditions)")
+        if not args.dry_run:
+            path.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

scripts/merge_language_hessians.py

@@ -19,6 +19,8 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--damping", type=float, default=1e-3)
     parser.add_argument("--output", type=Path, required=True)
     parser.add_argument("--json-out", type=Path, default=None)
+    parser.add_argument("--en-json", type=Path, default=None, help="raw EN calibration.json, for provenance")
+    parser.add_argument("--ja-json", type=Path, default=None, help="raw JA calibration.json, for provenance")
     return parser.parse_args()
 
 
@@ -77,10 +79,19 @@ def main() -> None:
             )
 
     args.output.parent.mkdir(parents=True, exist_ok=True)
-    tmp = args.output.with_name(args.output.name + ".tmp")
+    tmp = args.output.with_name(args.output.name + ".tmp.npz")
     np.savez(tmp, **arrays)
     os.replace(tmp, args.output)
 
+    sources = {}
+    for key, path in (("en", args.en_json), ("ja", args.ja_json)):
+        if path and path.exists():
+            payload = json.loads(path.read_text(encoding="utf-8"))
+            sources[key] = {
+                name: payload.get(name)
+                for name in ("corpus", "samples", "max_tokens", "output_block", "damping", "raw_output", "overlap_checked")
+            }
+
     summary = {
         "en": str(args.en),
         "ja": str(args.ja),
@@ -89,8 +100,19 @@ def main() -> None:
         "arrays": len(arrays),
         "overlap_checked": True,
         "calibration_corpora": [str(args.en), str(args.ja)],
+        "sources": sources,
         "records": records,
     }
+    # carry the shared calibration settings so downstream audits can compare them
+    for name in ("samples", "max_tokens", "output_block"):
+        values = {source.get(name) for source in sources.values() if source.get(name) is not None}
+        if len(values) == 1:
+            summary[name] = values.pop()
+        elif len(values) > 1:
+            print(f"warning: {name} differs between en and ja: {values}")
+    corpora = [source.get("corpus") for source in sources.values() if source.get("corpus")]
+    if corpora:
+        summary["corpus"] = corpora
     if args.json_out:
         args.json_out.parent.mkdir(parents=True, exist_ok=True)
         args.json_out.write_text(json.dumps(summary, indent=2) + "\n")

scripts/pull_results.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Pull a results repository and summarise what landed.
+
+The Kaggle operator uploads ``<lane>/manifest.json`` + per-condition JSON to
+``<user>/uzu-results``. This downloads it and prints what is complete, what is
+missing, and whether any manifest reported problems, so nobody has to eyeball a
+directory tree.
+
+Usage:
+    python scripts/pull_results.py --repo kentasatomuse/uzu-results --out results/kentasatomuse
+    python scripts/pull_results.py --out results/kentasatomuse --skip-download
+    python scripts/pull_results.py --repo ... --out ... --json results/summary.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def load_manifests(root: Path) -> list[dict[str, Any]]:
+    manifests = []
+    for path in sorted(root.rglob("manifest.json")):
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            print(f"skip unreadable {path}")
+            continue
+        payload["_path"] = str(path)
+        manifests.append(payload)
+    return manifests
+
+
+def summarise(root: Path) -> dict[str, Any]:
+    manifests = load_manifests(root)
+    lanes = []
+    total_conditions = 0
+    problems: list[str] = []
+    for manifest in manifests:
+        results = manifest.get("results", [])
+        lane = {
+            "lane": manifest.get("lane") or Path(manifest["_path"]).parent.name,
+            "conditions": len(results),
+            "complete": sum(1 for result in results if result.get("status") == "complete"),
+            "problems": manifest.get("problems", []),
+            "spec": manifest.get("spec"),
+            "updated": manifest.get("updated"),
+            "path": manifest["_path"],
+        }
+        total_conditions += lane["conditions"]
+        problems.extend(f"{lane['lane']}: {problem}" for problem in lane["problems"])
+        lanes.append(lane)
+    return {
+        "lanes": lanes,
+        "lane_count": len(lanes),
+        "condition_count": total_conditions,
+        "problems": problems,
+    }
+
+
+def format_table(summary: dict[str, Any]) -> str:
+    lines = ["| lane | conditions | complete | problems | updated |", "|---|---:|---:|---:|---|"]
+    for lane in summary["lanes"]:
+        lines.append(
+            f"| {lane['lane']} | {lane['conditions']} | {lane['complete']} "
+            f"| {len(lane['problems'])} | {lane.get('updated') or '-'} |"
+        )
+    return "\n".join(lines)
+
+
+def download(repo: str, out: Path, revision: str | None) -> None:
+    command = ["hf", "download", repo, "--repo-type", "dataset", "--local-dir", str(out)]
+    if revision:
+        command += ["--revision", revision]
+    print("$ " + " ".join(command), flush=True)
+    subprocess.run(command, check=False)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--repo", default=None, help="HF dataset repo, e.g. <user>/uzu-results")
+    parser.add_argument("--revision", default=None)
+    parser.add_argument("--out", type=Path, required=True)
+    parser.add_argument("--skip-download", action="store_true")
+    parser.add_argument("--json", type=Path, default=None)
+    parser.add_argument("--strict", action="store_true", help="exit 1 when a manifest reports problems")
+    args = parser.parse_args()
+
+    if not args.skip_download:
+        if not args.repo:
+            parser.error("--repo is required unless --skip-download is set")
+        download(args.repo, args.out, args.revision)
+
+    if not args.out.exists():
+        raise SystemExit(f"nothing at {args.out}")
+
+    summary = summarise(args.out)
+    print(json.dumps(summary, indent=2, ensure_ascii=False)[:1500])
+    print()
+    print(format_table(summary))
+    print(f"\nlanes: {summary['lane_count']}  conditions: {summary['condition_count']}")
+    if summary["problems"]:
+        print("PROBLEMS")
+        for problem in summary["problems"]:
+            print(f"  - {problem}")
+        if args.strict:
+            raise SystemExit(1)
+    if args.json:
+        args.json.parent.mkdir(parents=True, exist_ok=True)
+        args.json.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        print(f"wrote {args.json}")
+
+
+if __name__ == "__main__":
+    main()

scripts/qad_finetune.py

@@ -53,6 +53,17 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--seq", type=int, default=128)
     parser.add_argument("--lr", type=float, default=1e-4)
     parser.add_argument("--muon-lr", type=float, default=1e-3)
+    parser.add_argument(
+        "--freeze-scales",
+        action="store_true",
+        help="train master_weights only; leave scales and zero-points fixed",
+    )
+    parser.add_argument(
+        "--warmup-steps",
+        type=int,
+        default=0,
+        help="linearly ramp the learning rate over this many steps",
+    )
     parser.add_argument(
         "--optimizer",
         choices=("muon", "adamw"),
@@ -184,9 +195,10 @@ def main() -> None:
 
     def collect_params(model):
         params = {}
+        trainable = ("master_weights",) if args.freeze_scales else ("master_weights", "scales", "master_zero_points")
         for path, leaf in jax.tree_util.tree_flatten_with_path(model)[0]:
             key = jax.tree_util.keystr(path)
-            if any(name in key for name in ("master_weights", "scales", "master_zero_points")) and isinstance(leaf, jax.Array):
+            if any(name in key for name in trainable) and isinstance(leaf, jax.Array):
                 params[key] = leaf
         return params
 
@@ -256,6 +268,11 @@ def main() -> None:
 
     params = clamp_scales(params)
     opt_state = optimizer.init(params)
+    print(
+        f"trainable: {'master_weights only' if args.freeze_scales else 'master_weights + scales + zero_points'}"
+        f"  warmup_steps={args.warmup_steps}",
+        flush=True,
+    )
 
     def loss_fn(current_params, ids):
         model = inject_params(student, current_params)
@@ -269,8 +286,10 @@ def main() -> None:
         return kl * (temperature**2)
 
     @jax.jit
-    def train_step(current_params, opt_state, ids):
+    def train_step(current_params, opt_state, ids, lr_factor):
         loss, grads = jax.value_and_grad(loss_fn)(current_params, ids)
+        if args.warmup_steps > 0:
+            grads = jax.tree_util.tree_map(lambda grad: grad * lr_factor, grads)
         grad_norm = optax.global_norm(grads)
         updates, new_state = optimizer.update(grads, opt_state, current_params)
         new_params = optax.apply_updates(current_params, updates)
@@ -311,6 +330,8 @@ def main() -> None:
         "adam_b1": args.adam_b1,
         "adam_b2": args.adam_b2,
         "scale_min": args.scale_min,
+        "freeze_scales": bool(args.freeze_scales),
+        "warmup_steps": args.warmup_steps,
     }
 
     def save_checkpoint(step: int, current_params, current_state, current_rng) -> None:
@@ -404,7 +425,10 @@ def main() -> None:
     for step in range(start_step, args.steps):
         ids = chunks[int(rng.integers(0, len(chunks)))]
         step_started = time.time()
-        params, opt_state, loss, grad_norm = train_step(params, opt_state, ids)
+        lr_factor = 1.0
+        if args.warmup_steps > 0:
+            lr_factor = min(1.0, (step + 1) / args.warmup_steps)
+        params, opt_state, loss, grad_norm = train_step(params, opt_state, ids, lr_factor)
         jax.block_until_ready(params)
         now = time.time()
         loss_value = float(loss)

scripts/run_lane.py

@@ -38,6 +38,57 @@ DEFAULT_CONDITION = {
     "raw_output": False,
 }
 DEFAULT_EVAL = {"max_sequences": 100, "max_tokens": 128, "min_tokens": 16}
+TRITON_MIN_CAPABILITY = 8.0
+
+
+def parse_compute_capabilities(output: str) -> list[float]:
+    capabilities = []
+    for line in output.splitlines():
+        text = line.strip().split(",")[0].strip()
+        try:
+            capabilities.append(float(text))
+        except ValueError:
+            continue
+    return capabilities
+
+
+def needs_triton_off(capabilities: list[float]) -> bool:
+    """XLA's Triton GEMM path only supports Ampere (cc 8.0) and newer."""
+    return any(capability < TRITON_MIN_CAPABILITY for capability in capabilities)
+
+
+def detect_compute_capabilities() -> list[float]:
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=compute_cap", "--format=csv,noheader"],
+            text=True,
+            capture_output=True,
+            check=False,
+            timeout=20,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return []
+    if result.returncode != 0:
+        return []
+    return parse_compute_capabilities(result.stdout)
+
+
+def find_dataset_dir(root: Path, name: str) -> Path | None:
+    """Locate a mounted dataset regardless of the /kaggle/input layout."""
+    candidates = [
+        root / name,
+        *sorted(root.glob(f"datasets/*/{name}")),
+        *sorted(root.glob(f"datasets/*/*/{name}")),
+    ]
+    for candidate in candidates:
+        if (candidate / "model.safetensors").exists():
+            return candidate
+    # last resort: any directory with both weights and a tokenizer
+    for weights in sorted(root.rglob("model.safetensors")):
+        directory = weights.parent
+        if (directory / "tokenizer.json").exists():
+            return directory
+    return None
 
 
 class Runner:
@@ -60,6 +111,13 @@ class Runner:
             "copy": self._script(paths.get("copy", "scripts/make_lalamo_eval_copy.py")),
         }
         self.lane = spec.get("lane") or spec_path.stem
+        capabilities = detect_compute_capabilities()
+        self.triton_off = needs_triton_off(capabilities)
+        if self.triton_off:
+            print(
+                f"GPU caps {capabilities}: disabling XLA Triton GEMM (needs >= {TRITON_MIN_CAPABILITY})",
+                flush=True,
+            )
         self.lane_dir = work / "out" / self.lane
         self.jax_platform = paths.get("jax_platform") or os.environ.get("JAX_PLATFORM_NAME") or None
 
@@ -75,15 +133,30 @@ class Runner:
         path = Path(value).expanduser()
         return path if path.is_absolute() else self.kit / path
 
+    def environment(self, base: dict[str, str] | None = None) -> dict[str, str]:
+        env = dict(os.environ if base is None else base)
+        if self.jax_platform:
+            env["JAX_PLATFORM_NAME"] = self.jax_platform
+        for key, value in (self.spec.get("paths", {}).get("env") or {}).items():
+            env[str(key)] = str(value)
+        flags = list(self.spec.get("paths", {}).get("xla_flags", []))
+        if self.triton_off:
+            flags.append("--xla_gpu_enable_triton_gemm=false")
+        existing = env.get("XLA_FLAGS", "")
+        for flag in flags:
+            if flag not in existing:
+                existing = (existing + " " + flag).strip()
+        if existing:
+            env["XLA_FLAGS"] = existing
+        return env
+
     def run(self, step: str, command: list[str], log: Path) -> None:
         display = " ".join(str(part) for part in command)
         print(f"$ {display}", flush=True)
         self.commands.append([str(part) for part in command])
         if self.dry_run:
             return
-        env = os.environ.copy()
-        if self.jax_platform:
-            env["JAX_PLATFORM_NAME"] = self.jax_platform
+        env = self.environment()
         started = time.time()
         with log.open("a", encoding="utf-8") as handle:
             handle.write(f"\n=== {step} {time.strftime('%H:%M:%S')} ===\n$ {display}\n")
@@ -112,6 +185,11 @@ class Runner:
             return target
 
         source = self.resolve(model.get("bf16_source"))
+        if source and not (source / "model.safetensors").exists() and model.get("bf16_source_auto"):
+            found = find_dataset_dir(Path("/kaggle/input"), source.name)
+            if found is not None:
+                print(f"bf16 source resolved to {found}", flush=True)
+                source = found
         if source and (source / "model.safetensors").exists():
             print(f"copy bf16 from {source} -> {target}", flush=True)
             if not self.dry_run:
@@ -376,6 +454,10 @@ class Runner:
                     str(merged),
                     "--json-out",
                     str(out / "calibration.json"),
+                    "--en-json",
+                    str(self.lane_dir / merge["en"] / "calibration.json"),
+                    "--ja-json",
+                    str(self.lane_dir / merge["ja"] / "calibration.json"),
                 ],
                 out / "lane.log",
             )
@@ -485,6 +567,11 @@ def main() -> None:
     parser.add_argument("--hf-results", default=None, help="upload <lane_dir> to this HF dataset repo")
     parser.add_argument("--skip-merge", action="store_true")
     parser.add_argument("--work", default=None, help="override spec.paths.work")
+    parser.add_argument(
+        "--shard",
+        default=None,
+        help="run only part of the condition list, e.g. 0/3. Merges are not allowed with sharding.",
+    )
     args = parser.parse_args()
 
     spec = json.loads(args.spec.read_text(encoding="utf-8"))
@@ -492,6 +579,22 @@ def main() -> None:
     if not conditions and not spec.get("merge"):
         raise SystemExit("spec has no conditions")
 
+    if args.shard:
+        if spec.get("merge"):
+            raise SystemExit("--shard cannot be combined with spec.merge")
+        try:
+            index_text, count_text = args.shard.split("/")
+            index, count = int(index_text), int(count_text)
+        except ValueError:
+            raise SystemExit("--shard must look like 0/3")
+        if count <= 0 or not 0 <= index < count:
+            raise SystemExit("--shard index out of range")
+        conditions = [condition for position, condition in enumerate(conditions) if position % count == index]
+        if not conditions:
+            raise SystemExit(f"shard {args.shard} has no conditions")
+        spec["conditions"] = conditions
+        spec["lane"] = f"{spec['lane']}-shard{index + 1}of{count}"
+
     runner = Runner(spec, args.spec, dry_run=args.dry_run)
     if args.work:
         runner.work = Path(args.work).expanduser()