Rebuild: 6c480a5f (env fingerprint + verified publish)

kit_manifest.json

@@ -1,5 +1,13 @@
 {
-  "built_from_commit": "6d843d1d882722d70488fafa163a8925b6249eb3",
+  "built_from_commit": "6c480a5f6224f7598c6c0b6388bcadc8f16502a5",
+  "capabilities": [
+    "rht_int4_convert.layer_filter",
+    "eval_quantized.dtype",
+    "preflight",
+    "preflight.sdpa_xla",
+    "env_fingerprint",
+    "qad.freeze_scales"
+  ],
   "files": {
     "scripts/rht_int4_convert.py": "86419eb87505d7d08737163043ff7989d338a868ddbd08e72ae3185f37ba2819",
     "scripts/rewrite_lalamo_hybrid_spec.py": "154564c88391f81b5c24f64125d99abc15d81bd082a8264e36d43a00d4c47a04",
@@ -11,7 +19,7 @@
     "scripts/eval_quantized.py": "703904d36ff9f096aa2d7cfbad420318908834b34c2890d10e85aa05fb4fdd28",
     "scripts/qad_finetune.py": "26830bf55203a6a2e7fd79451c400949a1f6cdd1fc8d4011b62ff59d39c6e486",
     "scripts/compute_bpc.py": "2b55fd1df406d54b40daeeca2ecaf2efb35981655f5bf5e0cc10c057ce796256",
-    "scripts/run_lane.py": "486beac814f99994beab940025c59ce4104a9be5cb5de95fb9af32a6a3a602d7",
+    "scripts/run_lane.py": "cd74b56651cdff82b4ff12ab74fa84ecce1a658eb205c72faa1f6b770148ada6",
     "scripts/make_sweep_spec.py": "dc31ec026c89e7db316a185575a4423bca988c2ac6cf08ef6df8f955328cda69",
     "scripts/make_smoke_specs.py": "a76091d7a6a38427cdde5264a49d7bb4d8bfcc75284705817dd4c83b012bba2e",
     "scripts/combine_lane_manifests.py": "164ba691d60b3e2987b805426c606d135dcf3cf0c855b38cf7f5d6d57628a481",
@@ -25,11 +33,13 @@
     "scripts/dedup_lines.py": "d7caa00dc29f0ba48bc1bdac675e2ed5d81f0514d5d9df17a8f5b2017e6ea8d4",
     "scripts/dedup_calibration.py": "62ecc3c3921d307048c9e3547026634b616110115baf561f74dfb74c91e89b7d",
     "scripts/check_experiment.py": "a2e7e40909f68031dfccd7013ed055dfbc0ebb21f2a619622b71e6772c685ca5",
-    "scripts/check_docs.py": "e867ccced2e240fadd9a467dcca018e0d668c5e92ddccaeb4f9f936252f7883d",
-    "scripts/preflight.py": "4f713d8a3c0c6b18cfbebbcdb9c16c50cd51be31d9da63ce3e78f12863a090f2",
+    "scripts/check_docs.py": "b293dab14b2e8ebb63b32b07ec4454ca08b7bee194ee10c56871a340c6c8eda6",
+    "scripts/preflight.py": "5c2bcbe3693c8abf645fbf3f8160d96fdc1695daf09dc4961464ca8a23698e6e",
+    "scripts/env_fingerprint.py": "651db85ad3cdf28bc46e97010986109df60785eb6646507ee38b0fa75dce57d5",
+    "scripts/kaggle_slots.py": "e3baafe52347e74158c5b82fe6a2849f72a201d8ce60c0bbbf0871e47c75ae79",
     "scripts/tiny_sharding_probe.py": "29eb58f2689242b919616f6aab6ff753e0de031b16371137975b4d645e836fae",
     "scripts/audit_public_corpus.py": "84f1ec805a74004e71f63a70a8ed19967cb3fad9966f254798e655ab95e53ab0",
-    "scripts/build_kit.py": "93d86c32562c1485a3164649355874d68b24695f3252ac9d863c02e95c0ac9e8",
+    "scripts/build_kit.py": "1f8c3519fe8ffe29963b80f81d066de554b30f2294f993dee737b62e6bbb2541",
     "scripts/bootstrap_kaggle.py": "1633e3edbb80976c337444e3e4544e2b5210b2d8d1821e3a2717c1099c00843e",
     "data/calibration_en_wikitext2_dedup.txt": "18a79f4f938cc25747a90a12b120c7131e7f4ac55b58dfc691795ea61d4b5e9a",
     "data/calibration_ja_wikipedia_dedup.txt": "b45e3f3f00f2137be280a75c1fa9c9883a7e69d289257c4388fc701f33fee0d1",

scripts/build_kit.py

@@ -59,6 +59,8 @@ KIT_SCRIPTS = [
     "check_experiment.py",
     "check_docs.py",
     "preflight.py",
+    "env_fingerprint.py",
+    "kaggle_slots.py",
     # sharding / audit
     "tiny_sharding_probe.py",
     "audit_public_corpus.py",
@@ -143,6 +145,9 @@ def build(output: Path) -> list[str]:
     MANIFEST_NAME = "kit_manifest.json"
     manifest = {
         "built_from_commit": source_commit(),
+        # Downstream kernels should assert these, not an exact commit hash:
+        # the kit is rebuilt often, but a capability answers the real question.
+        "capabilities": detect_capabilities(output),
         "files": {
             name: sha256(output / name) for name in copied
         },
@@ -151,6 +156,28 @@ def build(output: Path) -> list[str]:
     return copied
 
 
+def detect_capabilities(root: Path) -> list[str]:
+    """Features a consumer may depend on, independent of the commit hash."""
+    wanted = {
+        "rht_int4_convert.layer_filter": ("scripts/rht_int4_convert.py", "--layer-filter"),
+        "eval_quantized.dtype": ("scripts/eval_quantized.py", "--dtype"),
+        "preflight": ("scripts/preflight.py", "def verdict"),
+        "preflight.sdpa_xla": ("scripts/preflight.py", "sdpa_xla"),
+        "env_fingerprint": ("scripts/env_fingerprint.py", "lalamo_code_hashes"),
+        "qad.freeze_scales": ("scripts/qad_finetune.py", "--freeze-scales"),
+    }
+    found = []
+    for name, (relative, needle) in wanted.items():
+        path = root / relative
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        if needle in text:
+            found.append(name)
+    return found
+
+
 def local_modules(scripts: list[Path]) -> dict[str, set[str]]:
     """Map module name -> places where it is imported, for kit-local modules."""
     available = {path.stem for path in scripts}

scripts/check_docs.py

@@ -36,6 +36,7 @@ DEFAULT_DOCS = [
     "docs/KAGGLE_SLOTS.md",
     "docs/EVAL.md",
     "docs/MODAL.md",
+    "docs/ENVIRONMENT.md",
     "tests/README.md",
     "antigravity/README.md",
 ]

scripts/env_fingerprint.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Canonical environment fingerprint for quantization runs.
+
+Version strings lie. PyPI ``lalamo==0.17.0`` (2026-09-24) and the pinned git
+commit ``e401e177`` (2026-11-02) both report 0.17.0, but the PyPI tree has no
+``compressed/incoherence.py``, so RHT cannot run there. Comparing results from
+those two installs is meaningless even though every version field matches.
+
+The fingerprint records two independent identities:
+
+1. where the package came from (``direct_url.json``: VCS URL + commit)
+2. hashes of the files that change numerics (RHT / INT4 / weight layout)
+
+(2) is the one to trust: identical hashes mean identical quantize/dequantize
+code, regardless of how the package was installed.
+
+Usage:
+    python scripts/env_fingerprint.py
+    python scripts/env_fingerprint.py --json out.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import platform
+import sys
+from importlib.metadata import distribution, version
+from pathlib import Path
+
+# Files that directly determine the quantized weights. A change in any of
+# these can move BPC, so they belong in every result manifest.
+FINGERPRINT_FILES = (
+    "compressed/incoherence.py",
+    "compressed/int.py",
+    "compressed/hybrid.py",
+    "compressed/quant_params.py",
+    "weight_matrix.py",
+)
+
+
+def file_sha256(path: Path) -> str | None:
+    try:
+        return hashlib.sha256(path.read_bytes()).hexdigest()
+    except OSError:
+        return None
+
+
+def parse_direct_url(text: str | None) -> dict[str, str]:
+    """Extract the VCS source of an installed distribution.
+
+    PyPI and a git checkout can both report version 0.17.0 while shipping
+    different code, so the version string alone is not provenance.
+    """
+    try:
+        payload = json.loads(text or "")
+    except (TypeError, ValueError):
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    result: dict[str, str] = {}
+    url = payload.get("url")
+    if url:
+        result["source"] = url
+    commit = (payload.get("vcs_info") or {}).get("commit_id")
+    if commit:
+        result["commit"] = commit
+    return result
+
+
+def lalamo_root() -> Path | None:
+    try:
+        import lalamo
+
+        return Path(lalamo.__file__).resolve().parent
+    except Exception:  # noqa: BLE001 - fingerprint must never break a run
+        return None
+
+
+def lalamo_provenance() -> dict[str, str]:
+    seen: dict[str, str] = {}
+    try:
+        seen["lalamo_version"] = version("lalamo")
+        parsed = parse_direct_url(distribution("lalamo").read_text("direct_url.json"))
+    except Exception:  # noqa: BLE001
+        return seen
+    if parsed.get("source"):
+        seen["lalamo_source"] = parsed["source"]
+    if parsed.get("commit"):
+        seen["lalamo_commit"] = parsed["commit"]
+    if not parsed:
+        seen["lalamo_source"] = "pypi-or-unknown"
+    return seen
+
+
+def lalamo_code_hashes(root: Path | None = None) -> dict[str, str]:
+    root = root or lalamo_root()
+    if root is None:
+        return {}
+    hashes: dict[str, str] = {}
+    missing = []
+    for relative in FINGERPRINT_FILES:
+        digest = file_sha256(root / relative)
+        if digest:
+            key = "lalamo_" + relative.replace("/", "_").replace(".py", "") + "_sha256"
+            hashes[key] = digest
+        else:
+            missing.append(relative)
+    hashes["lalamo_hash_complete"] = "false" if missing else "true"
+    if missing:
+        hashes["lalamo_hash_missing"] = ",".join(missing)
+    return hashes
+
+
+def fingerprint() -> dict[str, str]:
+    """Everything needed to decide whether two runs used the same code."""
+    seen: dict[str, str] = {"python_version": platform.python_version()}
+    try:
+        seen["jax_version"] = version("jax")
+    except Exception:  # noqa: BLE001
+        pass
+    seen.update(lalamo_provenance())
+    seen.update(lalamo_code_hashes())
+    return seen
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--json", type=Path, default=None)
+    args = parser.parse_args()
+
+    report = fingerprint()
+    text = json.dumps(report, indent=2, sort_keys=True)
+    print(text)
+    if args.json:
+        args.json.parent.mkdir(parents=True, exist_ok=True)
+        args.json.write_text(text + "\n", encoding="utf-8")
+    if not any(key.endswith("_sha256") for key in report):
+        print("warning: lalamo is not importable; no code hashes recorded", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

scripts/kaggle_slots.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Check how many Kaggle sessions are running before pushing another one.
+
+We accidentally had six CPU kernels alive. Kaggle silently drops whichever it
+wants, so the rule is: never exceed the per-account cap; wait in line instead.
+
+    python scripts/kaggle_slots.py                 # owner kernels from tasks/kernels.json
+    python scripts/kaggle_slots.py --extra yamahei21python/uzu-foo
+    python scripts/kaggle_slots.py --max 5 --json out.json
+
+Exit code is 1 when the account is full, so a shell guard can refuse the push.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+TASKS = ROOT / "tasks" / "kernels.json"
+
+TERMINAL = ("COMPLETE", "ERROR", "FAILED", "CANCEL", "CANCELLED")
+
+
+def status_of(kernel: str) -> str:
+    try:
+        result = subprocess.run(
+            ["kaggle", "kernels", "status", kernel], text=True, capture_output=True, check=False
+        )
+    except OSError:
+        return "unknown"
+    text = (result.stdout or "") + (result.stderr or "")
+    line = next((item.strip() for item in text.splitlines() if "status" in item.lower()), "")
+    return line or "unknown"
+
+
+def is_running(status: str) -> bool:
+    upper = status.upper()
+    if any(marker in upper for marker in TERMINAL):
+        return False
+    return "RUNNING" in upper or "QUEUED" in upper
+
+
+def count_running(statuses: list[str]) -> int:
+    return sum(1 for status in statuses if is_running(status))
+
+
+def owner_entries() -> list[dict]:
+    if not TASKS.exists():
+        return []
+    payload = json.loads(TASKS.read_text(encoding="utf-8"))
+    return [entry for entry in payload.get("kernels", []) if entry.get("owner") == "owner"]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--max-cpu", type=int, default=5)
+    parser.add_argument("--max-gpu", type=int, default=2)
+    parser.add_argument("--extra", action="append", default=[], help="additional kernel refs to count")
+    parser.add_argument("--json", type=Path, default=None)
+    args = parser.parse_args()
+
+    rows = []
+    for entry in owner_entries():
+        status = status_of(entry["ref"])
+        rows.append(
+            {
+                "kernel": entry["ref"],
+                "kind": entry.get("kind", "cpu"),
+                "status": status,
+                "running": is_running(status),
+            }
+        )
+    for kernel in args.extra:
+        status = status_of(kernel)
+        rows.append({"kernel": kernel, "kind": "cpu", "status": status, "running": is_running(status)})
+
+    cpu_running = sum(1 for row in rows if row["running"] and row["kind"] == "cpu")
+    gpu_running = sum(1 for row in rows if row["running"] and row["kind"] == "gpu")
+    running = cpu_running + gpu_running
+    print(f"{'kernel':34s} {'kind':5s} {'running':8s} status")
+    for row in rows:
+        print(
+            f"{row['kernel'].split('/')[-1]:34s} {row['kind']:5s} "
+            f"{'yes' if row['running'] else 'no':8s} {row['status'][:50]}"
+        )
+    print(f"\ncpu {cpu_running}/{args.max_cpu}   gpu {gpu_running}/{args.max_gpu}")
+
+    if args.json:
+        args.json.parent.mkdir(parents=True, exist_ok=True)
+        args.json.write_text(
+            json.dumps(
+                {"cpu_running": cpu_running, "gpu_running": gpu_running,
+                 "max_cpu": args.max_cpu, "max_gpu": args.max_gpu, "rows": rows},
+                indent=2,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+    if cpu_running >= args.max_cpu or gpu_running >= args.max_gpu:
+        print("account is full: wait for a slot instead of pushing another kernel")
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/preflight.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -44,8 +45,11 @@ def verdict(capabilities: list[float], probes: dict | None = None) -> dict:
     def status(name: str) -> str:
         return str(probes.get(name, "skip"))
 
-    core = ("dot", "dot_f32_acc", "sdpa_xla", "quant_roundtrip", "qad_grad", "tokenizer")
+    # qad_grad is checked separately: it needs a mesh context that non-QAD
+    # lanes never create, so a failure there must not block ordinary lanes.
+    core = ("dot", "dot_f32_acc", "sdpa_xla", "quant_roundtrip", "tokenizer")
     failures = [name for name in core if status(name) == "fail"]
+    qad_failure = status("qad_grad") == "fail"
     bf16 = all(status(name) == "pass" for name in ("dot", "dot_f32_acc", "sdpa_xla"))
 
     if status("sdpa_xla") == "fail":
@@ -65,6 +69,7 @@ def verdict(capabilities: list[float], probes: dict | None = None) -> dict:
         "probes": probes,
         "probe_failures": failures,
         "lane_ok": not failures,
+        "qad_ok": not qad_failure,
         "eval_dtype": "bfloat16" if bf16 else "float32",
         "attention": attention,
         "note": note,
@@ -135,7 +140,9 @@ PROBES = {
         "def loss(w):\n"
         "    return jnp.sum(spec.compress(w, key=jax.random.key(0), sharding_config=sharding).decompress() ** 2)\n"
         "w = jax.device_put(np.random.RandomState(0).randn(64, 32).astype(np.float32), sharding.resolve_sharding((None, None)))\n"
-        "grad = jax.grad(loss)(w)\n"
+        "mesh = sharding.resolve_sharding((None, None)).mesh\n"
+        "with jax.set_mesh(mesh):\n"
+        "    grad = jax.grad(loss)(w)\n"
         "assert bool(jnp.isfinite(grad).all())\n"
     ),
 }
@@ -144,6 +151,18 @@ PROBES = {
 LALAMO_PROBES = {"quant_roundtrip", "qad_grad"}
 
 
+def classify_probe_failure(name: str, message: str) -> tuple[str, str | None]:
+    """Missing top-level lalamo is a skip; a missing submodule is a failure.
+
+    The PyPI lalamo 0.17.0 tree reports ModuleNotFoundError for
+    ``lalamo.compressed.incoherence``. Treating that as "skip" would let the
+    wrong environment pass the gate.
+    """
+    if name in LALAMO_PROBES and re.search(r"No module named 'lalamo'(\s|$|\")", message):
+        return "skip", "lalamo not importable in this interpreter"
+    return "fail", message
+
+
 def run_probe(name: str, code: str, extra: list[str] | None = None) -> tuple[str, str | None]:
     """Returns (pass|fail|skip, error)."""
     try:
@@ -159,11 +178,10 @@ def run_probe(name: str, code: str, extra: list[str] | None = None) -> tuple[str
     if result.returncode == 0:
         return "pass", None
     message = (result.stderr or result.stdout or "").strip()[-400:] or "unknown failure"
-    if name in LALAMO_PROBES and "lalamo" in message and (
-        "ModuleNotFoundError" in message or "No module named" in message
-    ):
-        return "skip", "lalamo not importable in this interpreter"
-    return "fail", message
+    # Only a missing top-level package is a skip. A missing submodule means the
+    # installed lalamo is the wrong tree (PyPI 0.17.0 has no compressed/
+    # incoherence.py), which must fail the gate instead of being skipped.
+    return classify_probe_failure(name, message)
 
 
 def measure_probes(tokenizer_path: Path | None = None) -> tuple[dict, dict]:
@@ -236,6 +254,12 @@ def main() -> None:
         "kit_commit": kit_commit(Path("kit")),
     }
     report.update(verdict(capabilities, probes))
+    try:
+        from env_fingerprint import fingerprint
+
+        report["environment"] = fingerprint()
+    except Exception:  # noqa: BLE001 - older kits may not ship env_fingerprint.py
+        report["environment"] = {}
     report["jax_version"] = None
     try:
         from importlib.metadata import version

scripts/run_lane.py

@@ -92,6 +92,19 @@ def find_dataset_dir(root: Path, name: str) -> Path | None:
     return None
 
 
+try:
+    from env_fingerprint import fingerprint, lalamo_provenance, parse_direct_url
+except Exception:  # noqa: BLE001 - older kits may not ship env_fingerprint.py
+    def parse_direct_url(text: str) -> dict[str, str]:
+        return {}
+
+    def lalamo_provenance() -> dict[str, str]:
+        return {}
+
+    def fingerprint() -> dict[str, str]:
+        return {}
+
+
 class Runner:
     def __init__(self, spec: dict[str, Any], spec_path: Path, *, dry_run: bool = False) -> None:
         self.spec = spec
@@ -156,6 +169,7 @@ class Runner:
             seen["jax_version"] = version("jax")
         except Exception:  # noqa: BLE001 - provenance must never break a run
             pass
+        seen.update(lalamo_provenance())
         return seen
 
     def environment(self, base: dict[str, str] | None = None) -> dict[str, str]:
@@ -210,6 +224,15 @@ class Runner:
             print(f"preflight failed to produce a report (rc={result.returncode})", flush=True)
             return None
         report = json.loads(report_path.read_text(encoding="utf-8"))
+        probes = report.get("probes") or {}
+        if probes.get("quant_roundtrip") == "fail":
+            error = (report.get("probe_errors") or {}).get("quant_roundtrip", "")
+            raise SystemExit(
+                "preflight: lalamo has no working RHT quantize/dequantize path. "
+                "This is the PyPI 0.17.0 trap: install "
+                "git+https://github.com/trymirai/lalamo@e401e177 instead. "
+                f"{error}".strip()
+            )
         if (self.jax_platform or "").startswith("gpu") and report.get("attention") == "unavailable":
             raise SystemExit(
                 "preflight: dot_product_attention is unavailable on this GPU "
@@ -609,6 +632,7 @@ class Runner:
             "model": self.spec.get("model"),
             "eval": self.spec.get("eval"),
             "env": self.env_provenance(),
+            "environment_fingerprint": fingerprint(),
             "eval_dtype": self.eval_dtype,
             "results": summaries,
             "problems": problems,