diff --git a/tests/qwen38_campaign.bats b/tests/qwen38_campaign.bats
new file mode 100755
index 0000000..f061a8d
--- /dev/null
+++ b/tests/qwen38_campaign.bats
@@ -0,0 +1,527 @@
+#!/usr/bin/env bats
+# Seam: the Qwen3.8-Flash-Next five-bit campaign (feat/qwen38-w5nl64).
+#
+# The campaign converts the vendor BF16 checkpoint into a w5nl64a8h .rad on
+# dankserver while frank-archon keeps serving. Every gate that protects the box
+# or the result lives in a script under scripts/, and each gate is tested here
+# through that script's own exit status and printed output — no engine, no GPU,
+# no network. Fixtures are synthetic; the expected numbers are worked examples,
+# not values recomputed the way the script computes them.
+#
+# Seams under test (the campaign's public boundaries):
+#   scripts/download-qwen38-bf16.sh      fetch/verify of the BF16 checkpoint
+#   scripts/grams-to-imatrix.py          calibration recording -> imatrix GGUF
+#   scripts/derive-protected-experts.py  --target-count sweep + the parity law
+#   scripts/build-qwen38-bf16-rad.sh     the reference container's convert argv
+#   scripts/run-qwen38-bf16.sh           the drained-serve argv, mode selection
+#   scripts/convert-qwen38-w5nl64.sh     the arm driver's refusal gates
+#   scripts/kld-gate-qwen38.sh           the three-anchor interval law
+#   scripts/deploy-plan.py               campaign files must deploy nothing
+
+load helpers
+
+DOWNLOAD="$REPO_ROOT/scripts/download-qwen38-bf16.sh"
+PLANNER="$REPO_ROOT/scripts/deploy-plan.py"
+
+# make_shard <dir> <name> <total-bytes> — a REAL safetensors file whose size on
+# disk is exactly <total-bytes>: 8-byte header length, JSON header, tensor data.
+# Real, because the verifier reads each shard's own header to learn how many
+# bytes it claims to be, which is the only per-file truth available offline.
+make_shard() {
+    mkdir -p "$1"
+    python3 - "$1/$2" "$3" <<'PY'
+import json, struct, sys
+path, want = sys.argv[1], int(sys.argv[2])
+payload = max(0, want - 96)
+header = b""
+for _ in range(16):
+    # The header is part of the file, so its own length moves the target: solve
+    # payload = want - 8 - len(header(payload)) by fixed-point iteration.
+    header = json.dumps({"w": {"dtype": "F32", "shape": [payload // 4],
+                               "data_offsets": [0, payload]}},
+                        separators=(",", ":")).encode()
+    want_payload = want - 8 - len(header)
+    if want_payload == payload:
+        break
+    if want_payload < 0:
+        raise SystemExit("fixture too small to carry a header")
+    payload = want_payload
+else:
+    raise SystemExit("fixture header never converged")
+with open(path, "wb") as f:
+    f.write(struct.pack("<Q", len(header)) + header + b"\x00" * payload)
+PY
+}
+
+# make_index <dir> <shard>... — a safetensors index that references them
+make_index() {
+    local dir="$1"; shift
+    python3 - "$dir/model.safetensors.index.json" "$@" <<'PY'
+import json, sys
+out, names = sys.argv[1], sys.argv[2:]
+json.dump({"metadata": {"total_size": 0},
+           "weight_map": {f"model.layers.{i}.attn.q.weight": n
+                          for i, n in enumerate(names)}},
+          open(out, "w"))
+PY
+}
+
+# three_fixture <dir> — three valid 1000-byte shards plus the index naming them
+three_fixture() {
+    make_shard "$1" model-00001-of-00003.safetensors 1000
+    make_shard "$1" model-00002-of-00003.safetensors 1000
+    make_shard "$1" model-00003-of-00003.safetensors 1000
+    make_index "$1" model-00001-of-00003.safetensors \
+                  model-00002-of-00003.safetensors \
+                  model-00003-of-00003.safetensors
+}
+
+# --- download / verify -------------------------------------------------------
+
+@test "the checkpoint verifier accepts a complete checkpoint and reports its footprint" {
+    C="$BATS_TEST_TMPDIR/complete"
+    three_fixture "$C"
+    # 3 x 1000 bytes of shards. The index file itself is deliberately not
+    # counted, so a Hub-side edit to a config file cannot fail this gate.
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 3 --bytes 3000
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"VERIFY_OK"*"3 shards"*"3000 bytes"* ]]
+}
+
+@test "the verifier names the shard whose own header disagrees with its size on disk" {
+    C="$BATS_TEST_TMPDIR/truncated"
+    three_fixture "$C"
+    # Cut the tail, keep the header: that is a torn transfer, which is what the
+    # box actually gets from an interrupted fetch. Zero-filling instead would
+    # destroy the header and be caught as "not a safetensors file" — a different
+    # gate, and it would prove nothing about the size check.
+    python3 -c 'import sys
+p = sys.argv[1]
+keep = open(p, "rb").read(400)
+open(p, "wb").write(keep)' "$C/model-00002-of-00003.safetensors"
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 3 --bytes 3000
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"TRUNCATED"*"model-00002-of-00003.safetensors"* ]]
+}
+
+@test "the verifier refuses a missing shard and names it" {
+    C="$BATS_TEST_TMPDIR/missing"
+    three_fixture "$C"
+    mv "$C/model-00003-of-00003.safetensors" "$C/hidden.bin"
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 3 --bytes 3000
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"MISSING"*"model-00003-of-00003.safetensors"* ]]
+}
+
+@test "the verifier refuses when the shard census disagrees with the expected count" {
+    # The fragment law this repo learned the hard way: large quants ship as
+    # .partNofM fragments and a naive glob reports success on a partial tree.
+    C="$BATS_TEST_TMPDIR/count"
+    three_fixture "$C"
+    make_shard "$C" model-00004-of-00004.safetensors 1000
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 3 --bytes 3000
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"SHARD_COUNT"*"4"*"3"* ]]
+}
+
+@test "the verifier refuses a shard the index names that never landed" {
+    C="$BATS_TEST_TMPDIR/orphan-index"
+    three_fixture "$C"
+    rm "$C/model-00003-of-00003.safetensors"
+    make_index "$C" model-00001-of-00003.safetensors \
+                  model-00002-of-00003.safetensors \
+                  model-00003-of-00003.safetensors
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 2 --bytes 2000
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"MISSING"*"model-00003-of-00003.safetensors"* ]]
+}
+
+@test "the verifier treats an HTTP error body written as a shard as a failure, not a download" {
+    # curl -o FILE exits 0 on 401/403 and writes the error body; three shards
+    # of identical tiny size must never look like a checkpoint.
+    C="$BATS_TEST_TMPDIR/errorbody"
+    mkdir -p "$C"
+    for n in 1 2 3; do
+        printf '{"error":"You are not logged in"}' \
+            > "$C/model-0000${n}-of-00003.safetensors"
+    done
+    make_index "$C" model-00001-of-00003.safetensors \
+                  model-00002-of-00003.safetensors \
+                  model-00003-of-00003.safetensors
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 3 --bytes 3000
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"NOT_SAFETENSORS"* ]]
+}
+
+@test "the verifier refuses a shard census whose bytes do not total what the Hub declared" {
+    # Every shard header can be self-consistent and the tree still be the wrong
+    # payload: the total is the cross-check against the Hub's declared size.
+    C="$BATS_TEST_TMPDIR/wrongtotal"
+    three_fixture "$C"
+    run bash "$DOWNLOAD" --no-hub --dir "$C" --shards 3 --bytes 2500
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"TOTAL_BYTES"*"3000"*"2500"* ]]
+}
+
+@test "the fetch path refuses when the destination cannot hold the checkpoint" {
+    # The campaign's peak-disk law starts at the fetch: the BF16 checkpoint and
+    # the reference container built from it are both ~335 GiB, and the tree that
+    # does not fit is discovered hours into a transfer.
+    C="$BATS_TEST_TMPDIR/tiny"
+    three_fixture "$C"
+    run env FRANK_QWEN38_MIN_FREE_MIB=999999999 \
+        bash "$DOWNLOAD" --fetch --no-hub --dir "$C" --shards 3 --bytes 3000
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"REFUSED"*"free"* ]]
+}
+
+# --- deployment scoping ------------------------------------------------------
+
+@test "the campaign tooling deploys nothing: merging it cannot drain frank-archon" {
+    # Existence is asserted first: a planner that plans nothing because the
+    # files vanished would otherwise pass.
+    [ -f "$REPO_ROOT/scripts/download-qwen38-bf16.sh" ]
+    run python3 "$PLANNER" --target dankserver --paths \
+        scripts/download-qwen38-bf16.sh \
+        scripts/build-qwen38-bf16-rad.sh \
+        scripts/run-qwen38-bf16.sh \
+        scripts/convert-qwen38-w5nl64.sh \
+        scripts/kld-gate-qwen38.sh \
+        scripts/grams-to-imatrix.py \
+        scripts/recipes/qwen4exp-qwen38-w5nl64-bf16trunk.recipe \
+        tests/qwen38_campaign.bats
+    [ "$status" -eq 0 ]
+    [ -z "$output" ]
+}
+
+# --- protected experts -------------------------------------------------------
+
+DERIVE="$REPO_ROOT/scripts/derive-protected-experts.py"
+APPLY="$REPO_ROOT/scripts/apply-protected-cast.sh"
+CONVERT="$REPO_ROOT/scripts/convert-qwen38-w5nl64.sh"
+GATE="$REPO_ROOT/scripts/kld-gate-qwen38.sh"
+TEMPLATE="$REPO_ROOT/scripts/recipes/qwen4exp-qwen38-w5nl64-bf16trunk.recipe"
+
+# make_gram <dir> <layer> <expert> <energy> <rows> — a RADGRAM2 down-Gram whose
+# trace (its down-input energy) is <energy> and whose routing count is <rows>.
+make_gram() {
+    python3 - "$@" <<'PY'
+import os, struct, sys
+d, layer, e, energy, rows = sys.argv[1:6]
+os.makedirs(d, exist_ok=True)
+hdr = struct.pack("<8sIIQI4x", b"RADGRAM2", 2, 0, int(rows), 0)
+mat = struct.pack("<4f", float(energy), 0.0, 0.0, 0.0)
+with open(os.path.join(d, f"gram.r0.blk.{layer}.ffn_down_exps.{e}.bin"), "wb") as f:
+    f.write(hdr + mat)
+PY
+}
+
+# eight_grams <dir> — one layer, eight experts inside rank half 0, energies
+# 60/15/10/8/4/2/1/0.5 against equal routing. Under the default bars (3% of the
+# layer's energy AND 3x its routing share) exactly ONE expert is disproportionate,
+# so the parity law has to hand it a partner.
+eight_grams() {
+    local d="$1"
+    make_gram "$d" 0 0 60 100
+    make_gram "$d" 0 1 15 100
+    make_gram "$d" 0 2 10 100
+    make_gram "$d" 0 3 8 100
+    make_gram "$d" 0 4 4 100
+    make_gram "$d" 0 5 2 100
+    make_gram "$d" 0 6 1 100
+    make_gram "$d" 0 7 0.5 100
+}
+
+cast_count() { grep -c 'cast dtype=bf16' <<< "$output"; }
+
+@test "the bar-only pass keeps the disproportionate expert and repairs the odd rank half" {
+    C="$BATS_TEST_TMPDIR/calib"
+    eight_grams "$C"
+    run python3 "$DERIVE" "$C"
+    [ "$status" -eq 0 ]
+    # e0 holds 59.7% of the layer's energy on 12.5% of the routing: the only expert
+    # that clears three times its routing share. e1 joins it because half 0 was odd.
+    [ "$(cast_count)" -eq 2 ]
+    [[ "$output" == *"blk.0.ffn_*_exps.0.weight"* ]]
+    [[ "$output" == *"blk.0.ffn_*_exps.1.weight"* ]]
+    [[ "$output" != *"ffn_*_exps.2.weight"* ]]
+    [[ "$output" == *"half 0 odd -> added e1"* ]]
+}
+
+@test "--target-count lands the byte bill that was asked for, and never buys more" {
+    # The count is a disk and VRAM decision (each protected expert costs bf16 twice,
+    # once per rank half's copy), so landing it matters as much as not missing it.
+    C="$BATS_TEST_TMPDIR/calib"
+    eight_grams "$C"
+    run python3 "$DERIVE" "$C" --target-count 6
+    [ "$status" -eq 0 ]
+    [ "$(cast_count)" -eq 6 ]
+    [[ "$output" == *"count fill -> added e2"* ]]
+    [[ "$output" != *"ffn_*_exps.6.weight"* ]]
+    # the energy share the set bottoms out at is the bar the campaign paid for
+    [[ "$output" == *"total protected: 6 (target 6, energy cutoff"* ]]
+}
+
+@test "--target-count cannot invent experts: the pool's ceiling is reported, not padded" {
+    C="$BATS_TEST_TMPDIR/calib"
+    eight_grams "$C"
+    run python3 "$DERIVE" "$C" --target-count 20
+    [ "$status" -eq 0 ]
+    [ "$(cast_count)" -eq 8 ]
+    [[ "$output" == *"total protected: 8 (target 20"* ]]
+}
+
+@test "a protected set that cannot be made even is refused instead of emitted" {
+    # One disproportionate expert in half 0, its only companion in half 1: no
+    # candidate could make half 0 even, and an odd half hands the four-bit GEMM two
+    # tables that are not equal. Refusing is the only honest answer.
+    C="$BATS_TEST_TMPDIR/calib"
+    make_gram "$C" 0 0 100 100
+    make_gram "$C" 0 300 1 1000
+    run python3 "$DERIVE" "$C"
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"PARITY LAW BROKEN"* ]]
+    [[ "$output" == *"blk.0 half 0 holds 1"* ]]
+    [ "$(cast_count)" -eq 0 ]
+}
+
+@test "the splice rewrites the run's copy above the expert rule and refuses a second run" {
+    C="$BATS_TEST_TMPDIR/calib"
+    eight_grams "$C"
+    W="$BATS_TEST_TMPDIR/recipe-work.recipe"
+    cp "$TEMPLATE" "$W"
+    run env PY=python3 TRASH_DIR="$BATS_TEST_TMPDIR/trash" bash "$APPLY" "$C" "$W" 0
+    [ "$status" -eq 0 ]
+    grep -q "derive-protected-experts.py rewrote" "$W"
+    # The derived lines must precede the expert rule: the first rule whose glob
+    # matches a weight decides it, so a cast line below the expert line never fires.
+    cast_line=$(grep -n 'cast dtype=bf16' "$W" | head -1 | cut -d: -f1)
+    expert_line=$(grep -n 'ffn_\*_exps\.\*\.weight' "$W" | head -1 | cut -d: -f1)
+    [ "$cast_line" -lt "$expert_line" ]
+    # The committed template stays the clean, reviewable baseline.
+    ! grep -q "derive-protected-experts.py rewrote" "$TEMPLATE"
+    # A second run on the same copy would derive from a recording it already spent.
+    run env PY=python3 TRASH_DIR="$BATS_TEST_TMPDIR/trash" bash "$APPLY" "$C" "$W" 0
+    [ "$status" -ne 0 ]
+    [[ "$output" == *"refusing to re-derive"* ]]
+}
+
+@test "the splice refuses before touching the recipe when the count is not reached" {
+    C="$BATS_TEST_TMPDIR/calib"
+    eight_grams "$C"
+    W="$BATS_TEST_TMPDIR/recipe-work.recipe"
+    cp "$TEMPLATE" "$W"
+    run env PY=python3 TRASH_DIR="$BATS_TEST_TMPDIR/trash" bash "$APPLY" "$C" "$W" 20
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"target was 20"* ]]
+    ! grep -q "derive-protected-experts.py rewrote" "$W"
+}
+
+# --- the arm driver ----------------------------------------------------------
+
+# drv_fixture <dir> — the smallest tree the driver's gates accept: a checkpoint
+# with its index and tokenizer, three grams, an imatrix inside the campaign dir
+# the container mounts, and an empty output dir.
+drv_fixture() {
+    local d="$1"
+    mkdir -p "$d/ck/Qwen3.8-Flash-Next" "$d/campaign" "$d/calib" "$d/out"
+    : > "$d/ck/Qwen3.8-Flash-Next/model.safetensors.index.json"
+    : > "$d/ck/Qwen3.8-Flash-Next/tokenizer.json"
+    make_gram "$d/calib" 0 0 60 100
+    make_gram "$d/calib" 0 1 15 100
+    make_gram "$d/calib" 0 2 10 100
+    # four experts, not three: a thin pool that cannot be made even trips the parity
+    # audit, and this fixture is meant to reach the later gates
+    make_gram "$d/calib" 0 3 8 100
+    : > "$d/campaign/imatrix.gguf"
+}
+
+# run_drv <driver args and K=V overrides, any order> — the driver with every path
+# pointed at the fixture. Override words are separated out because `env` only
+# accepts assignments ahead of the command; later assignments win, so a test can
+# break exactly one input.
+run_drv() {
+    local d="$BATS_TEST_TMPDIR/drv" assigns=() flags=() w
+    for w in "$@"; do
+        if [[ "$w" =~ ^[A-Za-z_][A-Za-z0-9_]*= ]]; then assigns+=("$w"); else flags+=("$w"); fi
+    done
+    run env CKPT="$d/ck/Qwen3.8-Flash-Next" CAMPAIGN="$d/campaign" STATE="$d/campaign" \
+        CALIB="$d/calib" OUTDIR="$d/out" IMATRIX="$d/campaign/imatrix.gguf" \
+        MIN_GRAMS=2 TARGET_COUNT=0 ${assigns[@]+"${assigns[@]}"} \
+        bash "$CONVERT" ${flags[@]+"${flags[@]}"}
+}
+
+@test "the dry run prints the plan and then the convert for every arm" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    run_drv --dry-run
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"== arm cd3 =="* ]]
+    [[ "$output" == *"== arm cd6 =="* ]]
+    [[ "$output" == *"== arm ao1 =="* ]]
+    # one --plan-only bill per arm, and one convert line per arm beside it
+    [ "$(grep -c -- '--plan-only' <<< "$output")" -eq 3 ]
+    [ "$(grep -c 'rad-convert' <<< "$output")" -eq 6 ]
+    awk '/arm cd3/ {next}
+         /qwen38-w5nl64-cd3\.rad/ { if ($0 ~ /--plan-only/) p = NR; else c = NR }
+         END { exit !(p && c && p < c) }' <<< "$output"
+}
+
+@test "the cd6 arm re-sends the whole expert option set with cd=6; the control sends none" {
+    # --quant replaces the recipe line wholesale, so an override that forgot an
+    # option would quietly convert with the default for it.
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    run_drv --arm cd3 --arm cd6 --dry-run
+    [ "$status" -eq 0 ]
+    cd6line=$(grep -- '-cd6\.rad --quant' <<< "$output" | head -1)
+    [[ "$cd6line" == *"table=w5nl"* ]]
+    [[ "$cd6line" == *"group=64"* ]]
+    [[ "$cd6line" == *"scale=fp8_e4m3"* ]]
+    [[ "$cd6line" == *"transform=fwht128"* ]]
+    [[ "$cd6line" == *"calib=\$CALIB"* ]]
+    [[ "$cd6line" == *",cd=6"* ]]
+    cd3line=$(grep -- '-cd3\.rad' <<< "$output" | grep -v -- '--plan-only' | head -1)
+    [[ "$cd3line" != *"--quant"* ]]
+}
+
+@test "the ao1 arm carries act_order=1 and no cd=, because libquant refuses the pair" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    run_drv --arm ao1 --dry-run
+    [ "$status" -eq 0 ]
+    line=$(grep -- '-ao1\.rad --quant' <<< "$output" | head -1)
+    [[ "$line" == *"act_order=1"* ]]
+    [[ "$line" != *",cd="* ]]
+}
+
+@test "the driver splices the protected plane into its own copy, never the template" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    run_drv --dry-run
+    [[ "$output" == *"apply-protected-cast.sh $BATS_TEST_TMPDIR/drv/calib "* ]]
+    [[ "$output" == *"/campaign/recipe-"* ]]
+    [[ "$output" != *"$TEMPLATE"* ]]
+}
+
+@test "the driver refuses while the BF16 reference container still holds the volume" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    : > "$BATS_TEST_TMPDIR/drv/out/qwen38-bf16.rad"
+    run_drv --dry-run
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"peak-disk"* ]]
+}
+
+@test "a thin recording is refused: the driver never converts uncalibrated" {
+    # rad-convert converts WITHOUT a calibration recording with one stderr note,
+    # which is silently worse than a GPTQ run that failed.
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    run_drv MIN_GRAMS=9 --dry-run
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"run-qwen38-bf16.sh calib"* ]]
+}
+
+@test "an imatrix outside the mounted campaign dir is refused before any convert" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    mv "$BATS_TEST_TMPDIR/drv/campaign/imatrix.gguf" "$BATS_TEST_TMPDIR/imatrix.gguf"
+    run_drv IMATRIX="$BATS_TEST_TMPDIR/imatrix.gguf" --dry-run
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"not in the campaign dir"* ]]
+}
+
+@test "the driver never overwrites an arm that already exists" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    : > "$BATS_TEST_TMPDIR/drv/out/qwen38-w5nl64-cd6.rad"
+    run_drv --arm cd6 --dry-run
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"move it to trash first"* ]]
+}
+
+@test "an unknown arm name is refused before the gates run" {
+    # No fixture built: the name check must not need a checkpoint to exist.
+    run_drv --arm cd9 --dry-run
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"unknown arm: cd9"* ]]
+}
+
+@test "the driver stops when the protected derivation cannot land the target" {
+    drv_fixture "$BATS_TEST_TMPDIR/drv"
+    run_drv PY=python3 TARGET_COUNT=20 --arm cd3
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"target was 20"* ]]
+    [[ "$output" == *"would convert unprotected"* ]]
+    [[ "$output" != *"--entrypoint"* ]]
+}
+
+# --- the acceptance gate -----------------------------------------------------
+
+# kld_report <path> <model> <kl mean> <top1 fraction> — one score report, in the
+# shape `run-qwen38-bf16.sh score` writes: an `all` summary plus a per-source one.
+kld_report() {
+    python3 - "$@" <<'PY'
+import json, sys
+path, model, kl, top1 = sys.argv[1:5]
+kl, top1 = float(kl), float(top1)
+group = {"kld": {"mean": kl, "p99_9": kl * 4}, "top1_agreement": top1, "positions": 50432}
+json.dump({"model": model, "all": group,
+           "by_source": {"ops": dict(group, positions=20000)}}, open(path, "w"))
+PY
+}
+
+gate_case() { # gate_case <kl fp8> <kl iq4r> <kl cand> <top1 cand> [extra flags...]
+    D="$BATS_TEST_TMPDIR/kl"
+    mkdir -p "$D"
+    kld_report "$D/fp8.json" fp8-native "$1" 0.981
+    kld_report "$D/iq4r.json" iq4r-moe "$2" 0.962
+    kld_report "$D/cand.json" w5nl64 "$3" "$4"
+    run bash "$GATE" "$D/fp8.json" "$D/iq4r.json" "$D/cand.json" "${@:5}"
+}
+
+@test "an arm strictly inside the interval that closes half the gap passes" {
+    gate_case 0.0021 0.0190 0.0090 0.971
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"closes 59.2%"* ]]
+    [[ "$output" == *"KLD GATE PASS"* ]]
+}
+
+@test "an arm worse than the served payload fails the interval and the recovery" {
+    gate_case 0.0021 0.0190 0.0210 0.971
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"[FAIL] 2."* ]]
+    [[ "$output" == *"[FAIL] 3."* ]]
+    [[ "$output" == *"KLD GATE FAIL"* ]]
+}
+
+@test "anchors that are not ordered stop the gate: the instrument is wrong, not the arm" {
+    # If the near-lossless FP8 release does not sit CLOSER to the bf16 reference
+    # than the 4-bit payload does, the corpus, tokenizer or boot shape is broken and
+    # no arm number can mean anything.
+    gate_case 0.0300 0.0190 0.0120 0.971
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"[FAIL] 1."* ]]
+    [[ "$output" == *"gap is not positive"* ]]
+}
+
+@test "an arm measured outside the interval fails even when it looks better" {
+    # Closer to the reference than the achievable anchor is a measurement fault.
+    gate_case 0.0021 0.0190 0.0010 0.971
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"[FAIL] 2."* ]]
+}
+
+@test "an arm that buys KL with top-1 agreement fails" {
+    gate_case 0.0021 0.0190 0.0090 0.940
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"[PASS] 3."* ]]
+    [[ "$output" == *"[FAIL] 4."* ]]
+}
+
+@test "--recover tightens the same numbers until they fail" {
+    gate_case 0.0021 0.0190 0.0090 0.971 --recover 0.8
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"needs 80%"* ]]
+    [[ "$output" == *"[FAIL] 3."* ]]
+}
+
+@test "a slice the report does not carry is named, not guessed at" {
+    gate_case 0.0021 0.0190 0.0090 0.971 --slice code
+    [ "$status" -eq 2 ]
+    [[ "$output" == *"has no slice 'code'"* ]]
+    [[ "$output" == *"it has: ops"* ]]
+}