diff --git a/benchmarks/laya_mps/README.md b/benchmarks/laya_mps/README.md
index c296329..d1ae619 100644
--- a/benchmarks/laya_mps/README.md
+++ b/benchmarks/laya_mps/README.md
@@ -9,6 +9,10 @@ JSONL to `results/` (kept out of the repository); `report.py` builds the tables
 | `bench_inproc.py` | Laya in-process (no HTTP): load, warmup, first request, warm latency, memory |
 | `bench_http.py` | a `/v1/systemone` server, optionally started by the script and optionally behind the frontend: time to ready, first request, warm latency, throughput |
 | `paired.py` | two configurations compared request by request, both alive at once: two worker flag sets, or two running servers (e.g. a worker directly and through the frontend) |
+| `lengths.py` | first request of new input lengths and the memory it adds, for one or two worker flag sets |
+| `late_load.py` | a checkpoint loaded while serving: its first request directly and through the frontend |
+| `fallback.py` | Laya's fallback to the CPU on a GPU out-of-memory error, triggered by a lowered MPS memory limit |
+| `release.py` | in-process: what releasing PyTorch's MPS caches gives back after many lengths, and what it costs |
 | `profile_mps.py` | where a request's time goes on MPS |
 | `report.py` | tables from the JSONL, including the run-to-run gate and the answer comparison against a reference config |
 | `env.py` | shared: versions, checkpoint, hardware, power and load recorded with each run; memory footprint |
@@ -43,6 +47,53 @@ python benchmarks/laya_mps/paired.py --run f1 --a-url http://127.0.0.1:8000 --b-
 python benchmarks/laya_mps/paired.py --summarize benchmarks/laya_mps/results/paired_p1.jsonl
 ```
 
+## Reproduce every number in the recipe
+
+Each claim in the [recipe](../../recipe/laya/apple-silicon.md) comes from one of these commands. A
+rerun on another Mac, or under different load, gives other numbers; the comparison each command makes
+(A against B in the same run) is what carries over. Every script that measures refuses a run on battery
+power or above `--max-load`: a `--run` label other than `feasibility`, or for `late_load.py`,
+`fallback.py` and `release.py` a run without `--feasibility`; paired and lengths runs hold up better
+than separate ones under the load that remains, because both sides see it. Stop the recipe's worker and
+frontend first: the scripts start their own on ports 8000, 8001 and 8080.
+
+| recipe claim | command |
+| --- | --- |
+| checkpoint download time | `HF_HOME="$(mktemp -d)" python -c "import time, huggingface_hub as h; t = time.time(); h.snapshot_download('convaiinnovations/laya', allow_patterns=['rl_agent_config.json', 'model.safetensors', 'tokenizer/*', 'encoder/*']); print(f'{time.time() - t:.0f} s')"` |
+| first request after ready, time to ready, memory: worker against laya-serve, with and without the options | `bench_http.py` C3, C3w and C3o above, then `report.py` (phases and memory tables) |
+| first request after ready over many fresh starts | the loop below the table |
+| warm latency and answers, with the options against without | `paired.py --run p1 --a "" --b "--compile --weights fp16"` |
+| what each option contributes | `paired.py --run p2 --a "" --b=--compile`, `paired.py --run p3 --a "" --b "--weights fp16"`, and fp16 on top of compile: `paired.py --run p4 --a=--compile --b "--compile --weights fp16"` |
+| frontend overhead | start a worker on 8000 and the frontend on 8080 as in the recipe, then `paired.py --run f1 --a-url http://127.0.0.1:8000 --b-url http://127.0.0.1:8080` |
+| a request after an idle gap | `paired.py --run i1 --a "" --b "--compile --weights fp16" --gap 2 --only W1 -n 30 --discard 2`, and the same with `--gap 0.2`, `--gap 0.5`, `--gap 1` and `--gap 5` (each with its own `--run`) |
+| first request of a new input length; memory growth with the lengths seen | `lengths.py --run l1 --a "" --b "--compile --weights fp16"` (add `--first-words 1 --step 1 --lengths 1000` for every length up to the window) |
+| memory released by `torch.mps.empty_cache()` and the cost afterwards | `release.py --compile --weights fp16` |
+| a checkpoint loaded while serving, directly and through the frontend | `late_load.py --flags "--compile --weights fp16" --frontend target/release/omni-jev`, and without `--flags` |
+| fallback to the CPU on a GPU out-of-memory error | `fallback.py --limit-gb 3.5`, and `--limit-gb 2.5 --flags "--compile --weights fp16"` |
+| where the time goes | `profile_mps.py --run p1` |
+| two commits compared | start each worker from its own checkout on its own port, then `paired.py --a-url ... --b-url ...` |
+
+Each fresh start is one `bench_http.py` run, alternating the worker with the options and plain
+laya-serve; the phases table of `report.py` then lists the first request of every start on both
+sides (one measured run per start, so it needs an idle machine):
+
+```sh
+for i in $(seq 23); do
+  python benchmarks/laya_mps/bench_http.py --config C3o --run s$i --only W1 -n 1 --discard 1 \
+    --concurrency 1 --spawn .venv/bin/python -m frontend.laya_mps --device {device} --model {model} \
+    --compile --weights fp16 --port {port}
+  python benchmarks/laya_mps/bench_http.py --config C3 --run s$i --only W1 -n 1 --discard 1 \
+    --concurrency 1 --spawn .venv/bin/laya-serve
+done
+python benchmarks/laya_mps/report.py benchmarks/laya_mps/results/http_C3o_s*.jsonl \
+  benchmarks/laya_mps/results/http_C3_s*.jsonl --ref C3
+```
+
+All scripts are run as `python benchmarks/laya_mps/<script>` from the repository root; `--summarize`
+rebuilds a paired or lengths table from its JSONL. The published paired runs were made with the earlier
+environment-variable form of the options (`LAYA_WORKER_COMPILE=on LAYA_WORKER_WEIGHTS=fp16`), which the
+flags replace one for one.
+
 ## Results
 
 The measured runs on an M1 Pro are published as assets of one release on the fork,
diff --git a/benchmarks/laya_mps/bench_http.py b/benchmarks/laya_mps/bench_http.py
index da8eb4a..769e111 100644
--- a/benchmarks/laya_mps/bench_http.py
+++ b/benchmarks/laya_mps/bench_http.py
@@ -34,7 +34,7 @@
 HERE = Path(__file__).resolve().parent
 REPO = HERE.parents[1]
 sys.path.insert(0, str(HERE))
-from env import footprint_mb, header, noise_problems  # noqa: E402
+from env import footprint_mb, header, read_workloads, refuse_if_noisy  # noqa: E402
 
 CHECKPOINT = "convaiinnovations/laya"  # what laya-serve's "english" model resolves to (laya/router.py)
 
@@ -42,9 +42,11 @@
 class Client:
     """One keep-alive connection. Not thread-safe: one per thread."""
 
-    def __init__(self, url, token=None):
+    def __init__(self, url, token=None, timeout=120):
         parts = urlsplit(url)
-        self.conn = http.client.HTTPConnection(parts.hostname, parts.port or 80, timeout=120)
+        self.conn = http.client.HTTPConnection(
+            parts.hostname, parts.port or 80, timeout=timeout
+        )
         self.headers = {"Content-Type": "application/json"}
         if token:
             self.headers["Authorization"] = f"Bearer {token}"
@@ -107,18 +109,22 @@ def fetch_answers(client, body):
 
 
 def body_for(workload, model):
-    return json.dumps({"model": model, "state": workload["state"], "questions": workload["questions"]}).encode()
+    return json.dumps(
+        {"model": model, "state": workload["state"], "questions": workload["questions"]}
+    ).encode()
 
 
 def run_level(url, token, body, n, concurrency):
     """n requests split over `concurrency` threads. Returns [(thread, ms, status)], elapsed seconds."""
     per_thread = [n // concurrency + (i < n % concurrency) for i in range(concurrency)]
     results, lock = [], threading.Lock()
-    barrier = threading.Barrier(concurrency + 1, timeout=120)  # a thread that fails to connect breaks it
+    # a thread that fails to connect breaks it
+    barrier = threading.Barrier(concurrency + 1, timeout=120)
 
     def worker(index, count):
         client = Client(url, token)
-        client.request("POST", "/v1/systemone", body, retry=True)  # connect outside the timed window
+        # connect outside the timed window
+        client.request("POST", "/v1/systemone", body, retry=True)
         barrier.wait()
         mine = []
         for _ in range(count):
@@ -131,7 +137,9 @@ def worker(index, count):
         with lock:
             results.extend(mine)
 
-    threads = [threading.Thread(target=worker, args=(i, c)) for i, c in enumerate(per_thread)]
+    threads = [
+        threading.Thread(target=worker, args=(i, c)) for i, c in enumerate(per_thread)
+    ]
     for t in threads:
         t.start()
     barrier.wait()
@@ -146,36 +154,69 @@ def main():
     parser.add_argument("--config", required=True, help="label, e.g. C3 or C4")
     parser.add_argument("--run", required=True, help="feasibility, m1, m2, ...")
     parser.add_argument("--url", default="http://127.0.0.1:8000")
-    parser.add_argument("--model", default="english", help="model name the worker serves")
-    parser.add_argument("--frontend", help="Rust frontend binary to start on --url in front of the spawned worker")
-    parser.add_argument("--backend-port", type=int, default=8000, help="worker port when --frontend is used")
-    parser.add_argument("--spawn", nargs=argparse.REMAINDER, help="start this worker command, then benchmark it")
-    parser.add_argument("--device", default="mps", help="device for a spawned worker: LAYA_DEVICE and {device}")
+    parser.add_argument(
+        "--model", default="english", help="model name the worker serves"
+    )
+    parser.add_argument(
+        "--frontend",
+        help="Rust frontend binary to start on --url in front of the spawned worker",
+    )
+    parser.add_argument(
+        "--backend-port",
+        type=int,
+        default=8000,
+        help="worker port when --frontend is used",
+    )
+    parser.add_argument(
+        "--spawn",
+        nargs=argparse.REMAINDER,
+        help="start this worker command, then benchmark it",
+    )
+    parser.add_argument(
+        "--device",
+        default="mps",
+        help="device for a spawned worker: LAYA_DEVICE and {device}",
+    )
     parser.add_argument("--ready-timeout", type=float, default=600)
     parser.add_argument("--workloads", default=str(HERE / "workloads.jsonl"))
-    parser.add_argument("--only", nargs="*", help="bench workload ids to run (default: all)")
-    parser.add_argument("-n", type=int, default=300, help="timed requests per workload and concurrency level")
-    parser.add_argument("--discard", type=int, default=20, help="warmup requests per workload")
+    parser.add_argument(
+        "--only", nargs="*", help="bench workload ids to run (default: all)"
+    )
+    parser.add_argument(
+        "-n",
+        type=int,
+        default=300,
+        help="timed requests per workload and concurrency level",
+    )
+    parser.add_argument(
+        "--discard", type=int, default=20, help="warmup requests per workload"
+    )
     parser.add_argument("--concurrency", type=int, nargs="+", default=[1, 4])
     parser.add_argument("--seed", type=int, default=0, help="workload order seed")
     parser.add_argument("--out", default=str(HERE / "results"))
-    parser.add_argument("--max-load", type=float, default=2.0, help="1-min load average allowed for measured runs")
+    parser.add_argument(
+        "--max-load",
+        type=float,
+        default=2.0,
+        help="1-min load average allowed for measured runs",
+    )
     args = parser.parse_args()
     token = os.environ.get("OMNI_JEV_TEST_TOKEN")
     if args.frontend and not args.spawn:
-        parser.error("--frontend needs --spawn: the frontend is started in front of a spawned worker")
+        parser.error(
+            "--frontend needs --spawn: the frontend is started in front of a spawned worker"
+        )
     if args.frontend and urlsplit(args.url).port == args.backend_port:
         parser.error("--url and --backend-port must differ when --frontend is used")
 
-    problems = noise_problems(args.max_load)
-    if problems and args.run != "feasibility":
-        sys.exit("refusing a measured run: " + "; ".join(problems))
-    for problem in problems:
-        print(f"warning: {problem}", file=sys.stderr)
+    problems = refuse_if_noisy(args.max_load, args.run != "feasibility")
 
-    with open(args.workloads) as f:
-        workloads = [json.loads(line) for line in f if line.strip()]
-    bench = [w for w in workloads if w["kind"] == "bench" and (not args.only or w["id"] in args.only)]
+    workloads = read_workloads(args.workloads).values()
+    bench = [
+        w
+        for w in workloads
+        if w["kind"] == "bench" and (not args.only or w["id"] in args.only)
+    ]
     parity = [w for w in workloads if w["kind"] == "parity"]
 
     Path(args.out).mkdir(parents=True, exist_ok=True)
@@ -184,7 +225,9 @@ def main():
     def memory():
         mem = footprint_mb(processes["worker"].pid) if "worker" in processes else {}
         if "frontend" in processes:
-            mem["frontend_footprint_mb"] = footprint_mb(processes["frontend"].pid).get("footprint_mb")
+            mem["frontend_footprint_mb"] = footprint_mb(processes["frontend"].pid).get(
+                "footprint_mb"
+            )
         return mem
 
     out = Path(args.out) / f"http_{args.config}_{args.run}.jsonl"
@@ -201,12 +244,19 @@ def memory():
                 "LAYA_PRELOAD": "1",
                 "LAYA_LOG_LEVEL": "warning",
             }
-            env["PYTHONPATH"] = str(REPO / "src") + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
-            placeholders = {"{port}": str(port), "{device}": args.device, "{model}": args.model}
+            env["PYTHONPATH"] = str(REPO / "src") + (
+                os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else ""
+            )
+            placeholders = {
+                "{port}": str(port),
+                "{device}": args.device,
+                "{model}": args.model,
+            }
             command = list(args.spawn)
             for placeholder, value in placeholders.items():
                 command = [arg.replace(placeholder, value) for arg in command]
-            spawn_log = open(Path(args.out) / f"http_{args.config}_{args.run}.worker.log", "w")  # noqa: SIM115
+            log_path = Path(args.out) / f"http_{args.config}_{args.run}.worker.log"
+            spawn_log = open(log_path, "w")  # noqa: SIM115
             processes["worker"] = subprocess.Popen(
                 command, env=env, stdout=spawn_log, stderr=subprocess.STDOUT, cwd=REPO
             )
@@ -217,7 +267,8 @@ def memory():
                 "OMNI_JEV_BIND": f"{parts.hostname}:{parts.port}",
                 "OMNI_JEV_BACKEND_URL": f"http://127.0.0.1:{args.backend_port}",
             }
-            frontend_log = open(Path(args.out) / f"http_{args.config}_{args.run}.frontend.log", "w")  # noqa: SIM115
+            log_path = Path(args.out) / f"http_{args.config}_{args.run}.frontend.log"
+            frontend_log = open(log_path, "w")  # noqa: SIM115
             processes["frontend"] = subprocess.Popen(
                 [args.frontend], env=env, stdout=frontend_log, stderr=subprocess.STDOUT
             )
@@ -240,11 +291,20 @@ def emit(record):
                     health=health,
                     device_actual=health.get("device"),
                     # The worker reports these in /health; laya-serve does not, so its values are assumed.
-                    mps_amp_min_rows=health.get("mps_amp_min_rows", int(os.environ.get("LAYA_MPS_AMP_MIN_ROWS", "5"))),
+                    mps_amp_min_rows=health.get(
+                        "mps_amp_min_rows",
+                        int(os.environ.get("LAYA_MPS_AMP_MIN_ROWS", "5")),
+                    ),
                     amp_dtype=health.get("autocast_dtype")
-                    or ("torch.float16" if health.get("device") == "mps" else "torch.float32"),
+                    or (
+                        "torch.float16"
+                        if health.get("device") == "mps"
+                        else "torch.float32"
+                    ),
                     weights_dtype=health.get("weights_dtype") or "torch.float32",
-                    dtype_source=None if "weights_dtype" in health else "assumed: laya 0.3.20 defaults",
+                    dtype_source=None
+                    if "weights_dtype" in health
+                    else "assumed: laya 0.3.20 defaults",
                 )
             )
 
@@ -252,18 +312,24 @@ def emit(record):
             started = time.perf_counter()
             first_ms, routing = {}, None
             for w in bench:
-                ms, status, data = client.request("POST", "/v1/systemone", body_for(w, args.model), retry=True)
+                ms, status, data = client.request(
+                    "POST", "/v1/systemone", body_for(w, args.model), retry=True
+                )
                 if status != 200:
                     sys.exit(f"{w['id']}: status {status}: {data[:200]!r}")
                 first_ms[w["id"]] = ms
                 routing = json.loads(data).get("routing")
                 for _ in range(args.discard - 1):
-                    client.request("POST", "/v1/systemone", body_for(w, args.model), retry=True)
+                    client.request(
+                        "POST", "/v1/systemone", body_for(w, args.model), retry=True
+                    )
             warmup_s = time.perf_counter() - started
             emit(
                 {
                     "type": "phase",
-                    "process_to_ready_s": round(ready_s, 3) if "worker" in processes else None,
+                    "process_to_ready_s": round(ready_s, 3)
+                    if "worker" in processes
+                    else None,
                     "warmup_s": round(warmup_s, 3),
                     "first_ms": {k: round(v, 2) for k, v in first_ms.items()},
                     "routing": routing,
@@ -277,12 +343,15 @@ def emit(record):
             for w in order:
                 body = body_for(w, args.model)
                 answers, error = fetch_answers(client, body)
-                if error:  # the parity section of report.py reports the workload as missing
+                # the parity section of report.py reports the workload as missing
+                if error:
                     emit({"type": "answers_error", "workload": w["id"], **error})
                 else:
                     emit({"type": "answers", "workload": w["id"], "answers": answers})
                 for concurrency in args.concurrency:
-                    results, elapsed = run_level(args.url, token, body, args.n, concurrency)
+                    results, elapsed = run_level(
+                        args.url, token, body, args.n, concurrency
+                    )
                     ok = sum(s == 200 for _, _, s in results)
                     for i, (thread, ms, status) in enumerate(results):
                         emit(
diff --git a/benchmarks/laya_mps/bench_inproc.py b/benchmarks/laya_mps/bench_inproc.py
index ea048fd..5f7f9ce 100644
--- a/benchmarks/laya_mps/bench_inproc.py
+++ b/benchmarks/laya_mps/bench_inproc.py
@@ -23,12 +23,7 @@
 
 HERE = Path(__file__).resolve().parent
 sys.path.insert(0, str(HERE))
-from env import footprint_mb, header, noise_problems  # noqa: E402
-
-
-def load_workloads(path):
-    with open(path) as f:
-        return [json.loads(line) for line in f if line.strip()]
+from env import footprint_mb, header, read_workloads, refuse_if_noisy  # noqa: E402
 
 
 def sync(device):
@@ -57,22 +52,31 @@ def main():
     parser.add_argument("--run", required=True, help="feasibility, m1, m2, ...")
     parser.add_argument("--checkpoint", default="convaiinnovations/laya")
     parser.add_argument("--workloads", default=str(HERE / "workloads.jsonl"))
-    parser.add_argument("--only", nargs="*", help="bench workload ids to run (default: all)")
+    parser.add_argument(
+        "--only", nargs="*", help="bench workload ids to run (default: all)"
+    )
     parser.add_argument("-n", type=int, default=300, help="timed requests per workload")
-    parser.add_argument("--discard", type=int, default=20, help="warmup requests per workload")
+    parser.add_argument(
+        "--discard", type=int, default=20, help="warmup requests per workload"
+    )
     parser.add_argument("--seed", type=int, default=0, help="workload order seed")
     parser.add_argument("--out", default=str(HERE / "results"))
-    parser.add_argument("--max-load", type=float, default=2.0, help="1-min load average allowed for measured runs")
+    parser.add_argument(
+        "--max-load",
+        type=float,
+        default=2.0,
+        help="1-min load average allowed for measured runs",
+    )
     args = parser.parse_args()
 
-    problems = noise_problems(args.max_load)
-    if problems and args.run != "feasibility":
-        sys.exit("refusing a measured run: " + "; ".join(problems))
-    for problem in problems:
-        print(f"warning: {problem}", file=sys.stderr)
+    problems = refuse_if_noisy(args.max_load, args.run != "feasibility")
 
-    workloads = load_workloads(args.workloads)
-    bench = [w for w in workloads if w["kind"] == "bench" and (not args.only or w["id"] in args.only)]
+    workloads = read_workloads(args.workloads).values()
+    bench = [
+        w
+        for w in workloads
+        if w["kind"] == "bench" and (not args.only or w["id"] in args.only)
+    ]
     parity = [w for w in workloads if w["kind"] == "parity"]
 
     out = Path(args.out) / f"inproc_{args.config}_{args.device}_{args.run}.jsonl"
@@ -101,7 +105,10 @@ def emit(record):
             )
         )
         if agent.device.type != args.device:
-            print(f"warning: asked for {args.device}, laya is on {agent.device}", file=sys.stderr)
+            print(
+                f"warning: asked for {args.device}, laya is on {agent.device}",
+                file=sys.stderr,
+            )
 
         # Warmup: the first call per workload is kept apart, it is the first-shape cost.
         started = time.perf_counter()
@@ -140,13 +147,25 @@ def emit(record):
                     }
                 )
                 if i == 0:
-                    emit({"type": "answers", "workload": w["id"], "answers": result["answers"]})
+                    emit(
+                        {
+                            "type": "answers",
+                            "workload": w["id"],
+                            "answers": result["answers"],
+                        }
+                    )
 
         for w in parity:
             _, result = timed_call(agent, w)
             emit({"type": "answers", "workload": w["id"], "answers": result["answers"]})
 
-        emit({"type": "end", "total_s": round(time.perf_counter() - T_START, 1), **memory(agent.device)})
+        emit(
+            {
+                "type": "end",
+                "total_s": round(time.perf_counter() - T_START, 1),
+                **memory(agent.device),
+            }
+        )
     print(out)
 
 
diff --git a/benchmarks/laya_mps/env.py b/benchmarks/laya_mps/env.py
index 8ddcdd3..b2dae43 100644
--- a/benchmarks/laya_mps/env.py
+++ b/benchmarks/laya_mps/env.py
@@ -5,6 +5,7 @@
 """
 
 import importlib.metadata
+import json
 import os
 import platform
 import subprocess
@@ -17,7 +18,9 @@
 
 def _run(*cmd):
     try:
-        return subprocess.run(cmd, capture_output=True, text=True, timeout=10, check=True).stdout.strip()
+        return subprocess.run(
+            cmd, capture_output=True, text=True, timeout=10, check=True
+        ).stdout.strip()
     except (OSError, subprocess.SubprocessError):
         return None
 
@@ -35,7 +38,9 @@ def _checkpoint_revision(repo_id, ref="main"):
     try:
         from huggingface_hub.constants import HF_HUB_CACHE
 
-        ref_file = Path(HF_HUB_CACHE) / f"models--{repo_id.replace('/', '--')}" / "refs" / ref
+        ref_file = (
+            Path(HF_HUB_CACHE) / f"models--{repo_id.replace('/', '--')}" / "refs" / ref
+        )
         return ref_file.read_text().strip()
     except (ImportError, OSError):
         return None
@@ -66,13 +71,46 @@ def noise_problems(max_load):
     load = os.getloadavg()[0]
     if load > max_load:
         top = _run("ps", "-Ao", "pcpu=,comm=", "-r") or ""
-        busiest = "; ".join(" ".join(line.split()[:1] + [line.split("/")[-1]]) for line in top.splitlines()[:3])
+        busiest = "; ".join(
+            " ".join(line.split()[:1] + [line.split("/")[-1]])
+            for line in top.splitlines()[:3]
+        )
         problems.append(f"1-min load {load:.1f} > {max_load} (busiest: {busiest})")
     return problems
 
 
+def refuse_if_noisy(max_load, measured):
+    """Exits when a measured run would be noisy; otherwise warns about each problem and returns them."""
+    problems = noise_problems(max_load)
+    if problems and measured:
+        sys.exit("refusing a measured run: " + "; ".join(problems))
+    for problem in problems:
+        print(f"warning: {problem}", file=sys.stderr)
+    return problems
+
+
+def read_workloads(path):
+    """The fixed inputs by id, in file order."""
+    workloads = {}
+    with open(path) as f:
+        for w in map(json.loads, filter(str.strip, f)):
+            if w["id"] in workloads:
+                raise ValueError(f"{path}: workload id {w['id']} appears twice")
+            workloads[w["id"]] = w
+    return workloads
+
+
 def header(checkpoint, **extra):
-    status = _run("git", "-C", str(REPO), "status", "--porcelain", "--", ".", ":!benchmarks/laya_mps/results")
+    status = _run(
+        "git",
+        "-C",
+        str(REPO),
+        "status",
+        "--porcelain",
+        "--",
+        ".",
+        ":!benchmarks/laya_mps/results",
+    )
     return {
         "type": "env",
         "utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
@@ -84,7 +122,9 @@ def header(checkpoint, **extra):
         "torch": _version("torch"),
         "transformers": _version("transformers"),
         "python": platform.python_version(),
-        "os": f"macOS {platform.mac_ver()[0]}" if sys.platform == "darwin" else platform.platform(),
+        "os": f"macOS {platform.mac_ver()[0]}"
+        if sys.platform == "darwin"
+        else platform.platform(),
         "chip": _run("sysctl", "-n", "machdep.cpu.brand_string"),
         "cpu_perf_cores": _run("sysctl", "-n", "hw.perflevel0.physicalcpu"),
         "cpu_eff_cores": _run("sysctl", "-n", "hw.perflevel1.physicalcpu"),
@@ -97,6 +137,9 @@ def header(checkpoint, **extra):
     }
 
 
+RUSAGE_INFO_V4 = 4  # <sys/resource.h>
+
+
 def footprint_mb(pid=None):
     """Physical footprint of a process, now and its lifetime peak (MB), from proc_pid_rusage.
 
@@ -151,7 +194,10 @@ class RusageInfoV4(ctypes.Structure):  # <sys/resource.h>, rusage_info_v4
         return {}
     info = RusageInfoV4()
     libc = ctypes.CDLL("/usr/lib/libSystem.B.dylib", use_errno=True)
-    if libc.proc_pid_rusage(pid or os.getpid(), 4, ctypes.byref(info)) != 0:  # RUSAGE_INFO_V4
+    failed = libc.proc_pid_rusage(
+        pid or os.getpid(), RUSAGE_INFO_V4, ctypes.byref(info)
+    )
+    if failed:
         return {}
     return {
         "footprint_mb": round(info.phys_footprint / 2**20),
diff --git a/benchmarks/laya_mps/fallback.py b/benchmarks/laya_mps/fallback.py
new file mode 100644
index 0000000..c4cd0a8
--- /dev/null
+++ b/benchmarks/laya_mps/fallback.py
@@ -0,0 +1,103 @@
+"""Laya's fallback to the CPU on a GPU out-of-memory error, as the worker reports and serves it.
+
+Starts the worker on MPS with PyTorch's MPS memory limit lowered to `--limit-gb`, so that the model
+fits but a 64-question request near the window does not; then sends one short request, that large
+one, and short requests again, and prints /health before and after. The limit that triggers it
+depends on the Mac and the options: on a 16 GB M1 Pro, 3.5 GB without the options and 2.5 GB with
+`--compile --weights fp16`. Too low a limit makes the worker exit at startup (`--require-device`).
+
+    python benchmarks/laya_mps/fallback.py --limit-gb 3.5
+    python benchmarks/laya_mps/fallback.py --limit-gb 2.5 --flags "--compile --weights fp16"
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from bench_http import Client, body_for, wait_ready  # noqa: E402
+from env import read_workloads, refuse_if_noisy  # noqa: E402
+from paired import spawn, stop  # noqa: E402
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--limit-gb", type=float, required=True, help="MPS memory limit"
+    )
+    parser.add_argument("--flags", default="", help="frontend.laya_mps flags")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--workloads", default=str(HERE / "workloads.jsonl"))
+    parser.add_argument("--out", default=str(HERE / "results"))
+    parser.add_argument("--max-load", type=float, default=2.0)
+    parser.add_argument(
+        "--feasibility",
+        action="store_true",
+        help="run on battery or under load anyway; the numbers are not measurements",
+    )
+    args = parser.parse_args()
+    problems = refuse_if_noisy(args.max_load, not args.feasibility)
+    if problems:
+        print("not a measurement:", "; ".join(problems))
+    workloads = read_workloads(args.workloads)
+    probe = [
+        args.python,
+        "-c",
+        "import torch; print(torch.mps.recommended_max_memory())",
+    ]
+    probed = subprocess.run(probe, capture_output=True, text=True)
+    if probed.returncode:
+        sys.exit(f"{args.python} cannot report the MPS memory: {probed.stderr.strip()}")
+    recommended = int(probed.stdout)
+    ratio = args.limit_gb * 2**30 / recommended
+    limit = {
+        "PYTORCH_MPS_HIGH_WATERMARK_RATIO": f"{ratio:.4f}",
+        "PYTORCH_MPS_LOW_WATERMARK_RATIO": f"{ratio * 0.9:.4f}",
+    }
+    Path(args.out).mkdir(parents=True, exist_ok=True)
+    flags = f"--require-device {args.flags}"
+    log = Path(args.out) / "fallback.log"
+    worker = spawn(flags, args.port, args.python, "english", log, env=limit)
+    try:
+        url = f"http://127.0.0.1:{args.port}"
+        ready_s = wait_ready(url, {"worker": worker}, 900)[0]
+        client = Client(url)
+
+        def health():
+            h = json.loads(client.request("GET", "/health", retry=True)[2])
+            return {k: h.get(k) for k in ("device", "device_mismatch", "weights_dtype")}
+
+        def decide(workload, questions=None):
+            body = body_for(
+                {**workload, "questions": questions or workload["questions"]}, "english"
+            )
+            ms, status, _ = client.request("POST", "/v1/systemone", body, retry=True)
+            return status, round(ms)
+
+        print(
+            f"MPS limit {args.limit_gb} GB (ratio {ratio:.3f}), ready after {ready_s:.0f} s"
+        )
+        print("health before:", health())
+        print("short request (status, ms):", decide(workloads["W1"]))
+        large = {f"q{i}": workloads["W3"]["questions"]["route"] for i in range(64)}
+        started = time.monotonic()
+        status, _ = decide(workloads["W3"], large)
+        print(
+            f"64 questions near the window: status {status} after {time.monotonic() - started:.1f} s"
+        )
+        print("health after:", health())
+        print(
+            "short requests after (status, ms):",
+            [decide(workloads["W1"]) for _ in range(3)],
+        )
+    finally:
+        stop([worker])
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/laya_mps/late_load.py b/benchmarks/laya_mps/late_load.py
new file mode 100644
index 0000000..c89224c
--- /dev/null
+++ b/benchmarks/laya_mps/late_load.py
@@ -0,0 +1,167 @@
+"""A checkpoint Laya loads while the worker serves: how long its first request takes.
+
+Starts the worker on MPS with one checkpoint (`--model`), optionally the Rust frontend in front of
+it, then asks for another checkpoint (`--late`), directly and, with `--frontend`, through the
+frontend (a fresh worker for each). The first run also downloads the late checkpoint; run once
+beforehand to leave the download out. One JSON line per attempt:
+
+- `through`, `flags`, `late`: what was run;
+- `first`: status and time of the late request (504 from the frontend, or a client timeout, can
+  still be a load that succeeds in the worker);
+- `prepared_after_s`: when the worker stopped preparing the checkpoint;
+- `loaded`: whether the late checkpoint is resident afterwards; false means the load failed and the
+  worker unloaded it;
+- `next`: the same request again, sent only when `loaded`, otherwise null (it would load again);
+- `models`: device, revision and warmup time of each resident checkpoint;
+- `noise`: why the machine was not fit for a measurement (a `--feasibility` run), empty otherwise.
+
+    python benchmarks/laya_mps/late_load.py --flags "--compile --weights fp16" \\
+        --frontend target/release/omni-jev
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from bench_http import Client, wait_ready  # noqa: E402
+from env import refuse_if_noisy  # noqa: E402
+from paired import spawn, stop  # noqa: E402
+
+QUESTION = {
+    "q": {"type": "noul", "instructions": "Does the customer ask for a refund?"}
+}
+
+
+def attempt(args, through_frontend):
+    port, front = args.port, args.port + 1
+    log = (
+        Path(args.out) / f"late_load_{'frontend' if through_frontend else 'direct'}.log"
+    )
+    procs = [spawn(args.flags, port, args.python, args.model, log)]
+    try:
+        url = f"http://127.0.0.1:{port}"
+        wait_ready(url, {"worker": procs[0]}, args.ready_timeout)
+        if through_frontend:
+            env = {
+                **os.environ,
+                "OMNI_JEV_BIND": f"127.0.0.1:{front}",
+                "OMNI_JEV_BACKEND_URL": url,
+            }
+            procs.append(
+                subprocess.Popen(
+                    [args.frontend],
+                    env=env,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.STDOUT,
+                )
+            )
+            wait_ready(f"http://127.0.0.1:{front}", {"frontend": procs[1]}, 60)
+        client = Client(
+            f"http://127.0.0.1:{front if through_frontend else port}",
+            timeout=args.timeout,
+        )
+        body = json.dumps(
+            {
+                "model": args.late,
+                "state": "Please refund the duplicate charge.",
+                "questions": QUESTION,
+            }
+        ).encode()
+        worker = Client(url)
+
+        def health():
+            return json.loads(worker.request("GET", "/health", retry=True)[2])
+
+        resident = set(health()["models"])
+        started = time.monotonic()
+        try:
+            first_ms, first_status, _ = client.request("POST", "/v1/systemone", body)
+        except OSError as exc:
+            first_ms, first_status = (time.monotonic() - started) * 1000, repr(exc)
+        while health()["preparing"]:
+            time.sleep(0.2)
+        prepared_s = time.monotonic() - started
+        # A slow load can end in the frontend's 504 or a client timeout and still succeed; a failed one is
+        # unloaded, and a next request would only load it again.
+        loaded = bool(set(health()["models"]) - resident)
+        following = None
+        if loaded:
+            next_ms, next_status, _ = client.request(
+                "POST", "/v1/systemone", body, retry=True
+            )
+            following = {"status": next_status, "ms": round(next_ms, 1)}
+        final = health()
+        return {
+            "through": "frontend" if through_frontend else "direct",
+            "flags": args.flags,
+            "late": args.late,
+            "first": {"status": first_status, "ms": round(first_ms)},
+            "prepared_after_s": round(prepared_s, 1),
+            "loaded": loaded,
+            "next": following,
+            "models": {
+                name: {k: m.get(k) for k in ("device", "revision", "warmup_ms")}
+                for name, m in final["models"].items()
+            },
+        }
+    finally:
+        stop(procs)
+
+
+def parser():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--flags", default="", help="frontend.laya_mps flags")
+    parser.add_argument(
+        "--model", default="english", help="the checkpoint loaded at startup"
+    )
+    parser.add_argument(
+        "--late", default="multilingual", help="the checkpoint asked for later"
+    )
+    parser.add_argument(
+        "--frontend", help="Rust frontend binary: also time the request through it"
+    )
+    parser.add_argument(
+        "--port", type=int, default=8000, help="worker port; the frontend uses the next"
+    )
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--ready-timeout", type=float, default=900)
+    parser.add_argument("--out", default=str(HERE / "results"))
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=900,
+        help="seconds to wait for the late request; the first run also downloads the checkpoint",
+    )
+    parser.add_argument("--max-load", type=float, default=2.0)
+    parser.add_argument(
+        "--feasibility",
+        action="store_true",
+        help="run on battery or under load anyway; the numbers are not measurements",
+    )
+    return parser
+
+
+def main():
+    from laya.router import normalise_name
+
+    cli = parser()
+    args = cli.parse_args()
+    if normalise_name(args.late) == normalise_name(args.model):
+        cli.error(f"--late {args.late} is the checkpoint the worker starts with")
+    problems = refuse_if_noisy(args.max_load, not args.feasibility)
+    Path(args.out).mkdir(parents=True, exist_ok=True)
+    for through_frontend in (False, True) if args.frontend else (False,):
+        print(
+            json.dumps({**attempt(args, through_frontend), "noise": problems}),
+            flush=True,
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/laya_mps/lengths.py b/benchmarks/laya_mps/lengths.py
new file mode 100644
index 0000000..57491c5
--- /dev/null
+++ b/benchmarks/laya_mps/lengths.py
@@ -0,0 +1,239 @@
+"""New input lengths: what the first request of a length costs, and how the worker's memory grows.
+
+Starts one worker per flag set (all alive at once, like paired.py), warms each up, then sends every
+side a one-question request at each of `--lengths` lengths it has not seen, twice in a row. The
+first request's extra time is the first minus the second; memory is each worker's physical footprint
+before and after. Lengths the warmup ran are skipped, and the walk stops at the model's window.
+
+    python benchmarks/laya_mps/lengths.py --run l1 --a "" --b "--compile --weights fp16"
+    python benchmarks/laya_mps/lengths.py --run l2 --a "" --b "--compile --weights fp16" \\
+        --first-words 1 --step 1 --lengths 1000                     # every length up to the window
+    python benchmarks/laya_mps/lengths.py --summarize benchmarks/laya_mps/results/lengths_l1.jsonl
+"""
+
+import argparse
+import functools
+import json
+import statistics
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+sys.path.insert(0, str(HERE.parents[1] / "src"))
+from bench_http import Client, body_for, wait_ready  # noqa: E402
+from env import footprint_mb, header, read_workloads, refuse_if_noisy  # noqa: E402
+from paired import CHECKPOINT, spawn, stop  # noqa: E402
+
+from models.laya import engine  # noqa: E402
+
+
+def warmup_lengths(tokens_of):
+    """The input lengths the warmup ran: its one-question requests, sent through `tokens_of(state, questions)`."""
+    seen = set()
+
+    class Replay:
+        def predict(self, state, questions, model=None):
+            if len(questions) == 1:
+                seen.add(tokens_of(state, questions))
+            return {}
+
+    engine.warmup(Replay(), None, repeats=1)
+    return seen
+
+
+def measure(sides, request, first_words, step, count, seen, emit):
+    """Two requests per side at each input length the workers have not run, `count` lengths at most.
+
+    `request(side, words)` returns (ms, tokens). A length is known only after its first request, so a
+    length already in `seen` costs that one request and is skipped; the walk stops at the window, where a
+    longer state is truncated to a length already run."""
+    seen, measured, longest, words = set(seen), [], 0, first_words
+    stopped = "count"
+    while len(measured) < count:
+        order = sorted(sides, reverse=len(measured) % 2 == 1)
+        first, tokens = request(order[0], words)
+        if tokens <= longest:
+            stopped = "window"
+            break
+        longest = tokens
+        if tokens not in seen:
+            for s in order:
+                if s != order[0]:
+                    first, _ = request(s, words)
+                again, _ = request(s, words)
+                emit(
+                    {
+                        "type": "length",
+                        "side": s,
+                        "words": words,
+                        "tokens": tokens,
+                        "first_ms": first,
+                        "again_ms": again,
+                    }
+                )
+            seen.add(tokens)
+            measured.append((words, tokens))
+        words += step
+    emit(
+        {
+            "type": "walk",
+            "lengths": len(measured),
+            "stopped": stopped,
+            "longest_tokens": longest,
+        }
+    )
+    return measured
+
+
+def run(args):
+    problems = refuse_if_noisy(args.max_load, args.run != "feasibility")
+    question = read_workloads(args.workloads)["W1"]["questions"]
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    sides = {"A": args.a} if args.b is None else {"A": args.a, "B": args.b}
+    ports = {"A": args.port_a, "B": args.port_b}
+    procs = {}
+    path = out_dir / f"lengths_{args.run}.jsonl"
+    try:
+        for s, flags in sides.items():
+            log = out_dir / f"lengths_{args.run}_{s}.log"
+            procs[s] = spawn(flags, ports[s], args.python, args.model, log)
+        urls = {s: f"http://127.0.0.1:{ports[s]}" for s in sides}
+        for s in sides:
+            wait_ready(urls[s], {s: procs[s]}, args.ready_timeout)
+        clients = {s: Client(urls[s]) for s in sides}
+
+        def request(s, words):
+            state = {"state": " ".join(["invoice"] * words), "questions": question}
+            ms, status, data = clients[s].request(
+                "POST", "/v1/systemone", body_for(state, args.model), retry=True
+            )
+            if status != 200:
+                sys.exit(f"{s}: status {status} at {words} words: {data[:200]!r}")
+            return ms, json.loads(data)["usage"]["input_tokens"]
+
+        def tokens_of(s, state, questions):
+            body = body_for({"state": state, "questions": questions}, args.model)
+            reply = clients[s].request("POST", "/v1/systemone", body, retry=True)
+            return json.loads(reply[2])["usage"]["input_tokens"]
+
+        with open(path, "w") as f:
+
+            def emit(record):
+                f.write(json.dumps({"run": args.run, **record}) + "\n")
+
+            emit(
+                header(
+                    CHECKPOINT,
+                    a=f"frontend.laya_mps {args.a}".strip(),
+                    b=None if args.b is None else f"frontend.laya_mps {args.b}".strip(),
+                    lengths=args.lengths,
+                    noise=problems,
+                )
+            )
+            # The lengths the warmup ran, read back from the workers: those shapes are warm already.
+            seen = set()
+            for s in sides:
+                seen |= warmup_lengths(functools.partial(tokens_of, s))
+            before = {s: footprint_mb(procs[s].pid).get("footprint_mb") for s in sides}
+            measure(
+                sorted(sides),
+                request,
+                args.first_words,
+                args.step,
+                args.lengths,
+                seen,
+                emit,
+            )
+            health = {
+                s: json.loads(clients[s].request("GET", "/health", retry=True)[2])
+                for s in sides
+            }
+            after = {s: footprint_mb(procs[s].pid).get("footprint_mb") for s in sides}
+            emit(
+                {
+                    "type": "end",
+                    "footprint_before_mb": before,
+                    "footprint_after_mb": after,
+                    "recompiled_after_ready": {
+                        s: h.get("compile", {}).get("recompiled_after_ready")
+                        for s, h in health.items()
+                    },
+                }
+            )
+    finally:
+        stop(procs.values())
+    print(path)
+
+
+def summarize(paths):
+    for path in paths:
+        records = [json.loads(line) for line in Path(path).read_text().splitlines()]
+        env = records[0]
+        end = next((r for r in records if r["type"] == "end"), None)
+        walk = next((r for r in records if r["type"] == "walk"), None)
+        if walk is None:
+            stopped = "stop reason not recorded" if end else "the run did not finish"
+        elif walk["stopped"] == "window":
+            stopped = f"stopped at the window, {walk['longest_tokens']} tokens"
+        else:
+            stopped = f"stopped after the {walk['lengths']} lengths asked for"
+        print(f"## {env['run']}: load at start {env['loadavg_1m']}, {stopped}\n")
+        print(
+            "| side | flags | lengths | extra ms on first request, median (p90) "
+            "| footprint before → after MB | recompiled after ready |"
+        )
+        print("|---|---|---|---|---|---|")
+        for s in ("A", "B"):
+            rows = [r for r in records if r["type"] == "length" and r["side"] == s]
+            if not rows:
+                continue
+            extra = sorted(r["first_ms"] - r["again_ms"] for r in rows)
+            p90 = extra[max(0, int(0.9 * len(extra)) - 1)]
+            memory = "unfinished"
+            recompiled = None
+            if end:
+                before = end["footprint_before_mb"].get(s)
+                after = end["footprint_after_mb"].get(s)
+                memory = f"{before} → {after}"
+                recompiled = end["recompiled_after_ready"].get(s)
+            print(
+                f"| {s} | `{env[s.lower()]}` | {len(rows)} "
+                f"| {statistics.median(extra):.1f} ({p90:.1f}) | {memory} | {recompiled} |"
+            )
+        print()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--summarize", nargs="+", metavar="JSONL")
+    parser.add_argument("--run")
+    parser.add_argument(
+        "--a", default="", help="frontend.laya_mps flags for side A (default: none)"
+    )
+    parser.add_argument(
+        "--b", help="flags for an optional side B; a single flag: --b=--compile"
+    )
+    parser.add_argument("--lengths", type=int, default=100, help="new lengths per side")
+    parser.add_argument("--first-words", type=int, default=37)
+    parser.add_argument("--step", type=int, default=4, help="words between two lengths")
+    parser.add_argument("--port-a", type=int, default=8000)
+    parser.add_argument("--port-b", type=int, default=8001)
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--model", default="english")
+    parser.add_argument("--workloads", default=str(HERE / "workloads.jsonl"))
+    parser.add_argument("--ready-timeout", type=float, default=900)
+    parser.add_argument("--max-load", type=float, default=2.0)
+    parser.add_argument("--out", default=str(HERE / "results"))
+    args = parser.parse_args()
+    if args.summarize:
+        summarize(args.summarize)
+    elif args.run:
+        run(args)
+    else:
+        parser.error("give --run or --summarize")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/laya_mps/paired.py b/benchmarks/laya_mps/paired.py
index dfed172..9a078dd 100644
--- a/benchmarks/laya_mps/paired.py
+++ b/benchmarks/laya_mps/paired.py
@@ -3,12 +3,16 @@
 
     python benchmarks/laya_mps/paired.py --run p1 --a "" --b "--compile --weights fp16"
     python benchmarks/laya_mps/paired.py --run f1 --a-url http://127.0.0.1:8000 --b-url http://127.0.0.1:8080
+    python benchmarks/laya_mps/paired.py --run i1 --a "" --b "--compile --weights fp16" \
+        --gap 2 --only W1 -n 30 --discard 2
     python benchmarks/laya_mps/paired.py --summarize benchmarks/laya_mps/results/paired_p1.jsonl
 
 `--a`/`--b` are extra flags for `frontend.laya_mps`, which the script starts on MPS with the english
 model; `--a-url`/`--b-url` compare two servers that are already running (e.g. a worker directly and
 through the Rust frontend). The summary reports, per input, the median of the per-pair ratio B/A with a
-95% bootstrap interval, and B's answers against A's.
+95% bootstrap interval, and B's answers against A's. With `--gap`, every request follows that many
+seconds of idle on a fresh connection, as an agent asking now and then would see it; without it, requests
+are back to back.
 """
 
 import argparse
@@ -20,19 +24,20 @@
 import statistics
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 HERE = Path(__file__).resolve().parent
 REPO = HERE.parents[1]
 sys.path.insert(0, str(HERE))
 from bench_http import Client, body_for, fetch_answers, wait_ready  # noqa: E402
-from env import footprint_mb, header, noise_problems  # noqa: E402
+from env import footprint_mb, header, read_workloads, refuse_if_noisy  # noqa: E402
 
 CHECKPOINT = "convaiinnovations/laya"
 
 
-def spawn(flags, port, python, model, log_path):
-    env = {**os.environ, "PYTHONPATH": str(REPO / "src")}
+def spawn(flags, port, python, model, log_path, env=None):
+    env = {**os.environ, "PYTHONPATH": str(REPO / "src"), **(env or {})}
     command = [
         python,
         "-m",
@@ -48,16 +53,29 @@ def spawn(flags, port, python, model, log_path):
         *shlex.split(flags),
     ]
     log = open(log_path, "w")  # noqa: SIM115
-    return subprocess.Popen(command, env=env, stdout=log, stderr=subprocess.STDOUT, cwd=REPO)
+    return subprocess.Popen(
+        command, env=env, stdout=log, stderr=subprocess.STDOUT, cwd=REPO
+    )
+
+
+def stop(processes):
+    for p in processes:
+        p.terminate()
+    for p in processes:
+        try:
+            p.wait(timeout=30)
+        except subprocess.TimeoutExpired:
+            p.kill()
 
 
 def run(args):
-    problems = noise_problems(args.max_load)
-    if problems and args.run != "feasibility":
-        sys.exit("refusing a measured run: " + "; ".join(problems))
-    with open(args.workloads) as f:
-        workloads = [json.loads(line) for line in f if line.strip()]
-    bench = [w for w in workloads if w["kind"] == "bench"]
+    problems = refuse_if_noisy(args.max_load, args.run != "feasibility")
+    workloads = read_workloads(args.workloads).values()
+    bench = [
+        w
+        for w in workloads
+        if w["kind"] == "bench" and (not args.only or w["id"] in args.only)
+    ]
     parity = [w for w in workloads if w["kind"] == "parity"]
     out_dir = Path(args.out)
     out_dir.mkdir(parents=True, exist_ok=True)
@@ -74,8 +92,19 @@ def run(args):
     try:
         if not (args.a_url or args.b_url):
             for s, (flags, port) in sides.items():
-                procs[s] = spawn(flags, port, args.python, args.model, out_dir / f"paired_{args.run}_{s}.log")
-        health = {s: wait_ready(urls[s], {s: procs[s]} if s in procs else {}, args.ready_timeout)[1] for s in sides}
+                procs[s] = spawn(
+                    flags,
+                    port,
+                    args.python,
+                    args.model,
+                    out_dir / f"paired_{args.run}_{s}.log",
+                )
+        health = {
+            s: wait_ready(
+                urls[s], {s: procs[s]} if s in procs else {}, args.ready_timeout
+            )[1]
+            for s in sides
+        }
         with open(out_dir / f"paired_{args.run}.jsonl", "w") as f:
 
             def emit(record):
@@ -89,6 +118,7 @@ def emit(record):
                     n=args.n,
                     discard=args.discard,
                     seed=args.seed,
+                    gap_s=args.gap,
                     health=health,
                     noise=problems,
                 )
@@ -98,7 +128,15 @@ def emit(record):
                 body = body_for(w, args.model)
                 for s in sides:
                     answers, error = fetch_answers(clients[s], body)
-                    emit({"type": "answers", "side": s, "workload": w["id"], "answers": answers, "error": error})
+                    emit(
+                        {
+                            "type": "answers",
+                            "side": s,
+                            "workload": w["id"],
+                            "answers": answers,
+                            "error": error,
+                        }
+                    )
             order = bench[:]
             random.Random(args.seed).shuffle(order)
             for w in order:
@@ -107,8 +145,14 @@ def emit(record):
                     first, second = ("A", "B") if i % 2 == 0 else ("B", "A")
                     ms = {}
                     for s in (first, second):
+                        if args.gap:
+                            # uvicorn drops keep-alive after 5 s idle
+                            clients[s].close()
+                            time.sleep(args.gap)
                         try:
-                            t, status, _ = clients[s].request("POST", "/v1/systemone", body)
+                            t, status, _ = clients[s].request(
+                                "POST", "/v1/systemone", body
+                            )
                         except (OSError, http.client.HTTPException):
                             t, status = None, 0
                         ms[s] = t if status == 200 else None
@@ -124,29 +168,34 @@ def emit(record):
                                 "rows": len(w["questions"]),
                             }
                         )
-            end_health = {s: json.loads(clients[s].request("GET", "/health", retry=True)[2]) for s in sides}
+            end_health = {
+                s: json.loads(clients[s].request("GET", "/health", retry=True)[2])
+                for s in sides
+            }
             emit(
                 {
                     "type": "end",
                     "health": end_health,
-                    "footprint_mb": {s: footprint_mb(procs[s].pid).get("footprint_mb") for s in procs},
+                    "footprint_mb": {
+                        s: footprint_mb(procs[s].pid).get("footprint_mb") for s in procs
+                    },
                 }
             )
     finally:
-        for p in procs.values():
-            p.terminate()
-        for p in procs.values():
-            try:
-                p.wait(timeout=30)
-            except subprocess.TimeoutExpired:
-                p.kill()
+        stop(list(procs.values()))
     print(out_dir / f"paired_{args.run}.jsonl")
 
 
 def median_interval(ratios, seed=0, resamples=2000):
     rng = random.Random(seed)
-    meds = sorted(statistics.median(rng.choices(ratios, k=len(ratios))) for _ in range(resamples))
-    return statistics.median(ratios), meds[int(0.025 * resamples)], meds[int(0.975 * resamples) - 1]
+    meds = sorted(
+        statistics.median(rng.choices(ratios, k=len(ratios))) for _ in range(resamples)
+    )
+    return (
+        statistics.median(ratios),
+        meds[int(0.025 * resamples)],
+        meds[int(0.975 * resamples) - 1],
+    )
 
 
 def flat(answer):
@@ -171,8 +220,15 @@ def summarize(paths):
         with open(path) as f:
             records = [json.loads(line) for line in f if line.strip()]
         env = next(r for r in records if r["type"] == "env")
-        print(f"## {env['run']}: A = `{env['a']}`, B = `{env['b']}`, load at start {env['loadavg_1m']}\n")
-        print("| input | pairs | A p50 ms | B p50 ms | median B/A | 95% interval |\n|---|---|---|---|---|---|")
+        gap = env.get("gap_s")
+        pacing = f"{gap} s idle before each request" if gap else "back to back"
+        print(
+            f"## {env['run']}: A = `{env['a']}`, B = `{env['b']}`, {pacing}, "
+            f"load at start {env['loadavg_1m']}\n"
+        )
+        print(
+            "| input | pairs | A p50 ms | B p50 ms | median B/A | 95% interval |\n|---|---|---|---|---|---|"
+        )
         pairs, failed = {}, 0
         for r in records:
             if r["type"] == "pair" and r["a_ms"] and r["b_ms"]:
@@ -201,23 +257,37 @@ def summarize(paths):
                 if a is None or b is None or a.get("type") != b.get("type"):
                     errors.append(f"{wid}/{q}")
                     continue
-                worst = max(worst, max(abs(flat(a)[k] - flat(b).get(k, 0.0)) for k in flat(a)))
+                worst = max(
+                    worst, max(abs(flat(a)[k] - flat(b).get(k, 0.0)) for k in flat(a))
+                )
                 if decision(a) != decision(b):
                     flips.append((wid, q, round(margin(a), 4)))
-        print(f"\nB vs A answers: max |Δp| {worst:.4f}, flips {flips}, errors {errors}; failed pairs: {failed}")
+        print(
+            f"\nB vs A answers: max |Δp| {worst:.4f}, flips {flips}, errors {errors}; failed pairs: {failed}"
+        )
         end = next((r for r in records if r["type"] == "end"), None)
         if end is None:
-            print("**The run did not finish: no end record, so no device, recompile or memory check.**\n")
+            print(
+                "**The run did not finish: no end record, so no device, recompile or memory check.**\n"
+            )
             continue
-        compile_state = {s: h.get("compile", {}).get("recompiled_after_ready") for s, h in end["health"].items()}
+        compile_state = {
+            s: h.get("compile", {}).get("recompiled_after_ready")
+            for s, h in end["health"].items()
+        }
         devices = {s: h.get("device") for s, h in end["health"].items()}
         off_gpu = [
             s
             for s, h in end["health"].items()
             if h.get("device_mismatch")
-            or (h.get("compile", {}).get("enabled") and not h["compile"].get("active", True))
+            or (
+                h.get("compile", {}).get("enabled")
+                and not h["compile"].get("active", True)
+            )
         ]
-        print(f"recompiled after ready: {compile_state}; device at end: {devices}; footprint MB: {end['footprint_mb']}")
+        print(
+            f"recompiled after ready: {compile_state}; device at end: {devices}; footprint MB: {end['footprint_mb']}"
+        )
         if off_gpu:
             print(
                 f"**Side {', '.join(off_gpu)} left its device or compiled path during the run; the ratios above mix both.**"
@@ -229,9 +299,17 @@ def main():
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     parser.add_argument("--summarize", nargs="+", metavar="JSONL")
     parser.add_argument("--run")
-    parser.add_argument("--a", help="extra frontend.laya_mps flags for side A (default: none)")
-    parser.add_argument("--b", help="extra frontend.laya_mps flags for side B (default: --compile --weights fp16)")
-    parser.add_argument("--a-url", help="instead of starting workers: an already running server for side A")
+    parser.add_argument(
+        "--a", help="extra frontend.laya_mps flags for side A (default: none)"
+    )
+    parser.add_argument(
+        "--b",
+        help="extra frontend.laya_mps flags for side B (default: --compile --weights fp16)",
+    )
+    parser.add_argument(
+        "--a-url",
+        help="instead of starting workers: an already running server for side A",
+    )
     parser.add_argument("--b-url", help="... and for side B")
     parser.add_argument("--port-a", type=int, default=8000)
     parser.add_argument("--port-b", type=int, default=8001)
@@ -241,6 +319,10 @@ def main():
     parser.add_argument("-n", type=int, default=300, help="timed pairs per input")
     parser.add_argument("--discard", type=int, default=20)
     parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument(
+        "--gap", type=float, default=0, help="seconds of idle before every request"
+    )
+    parser.add_argument("--only", nargs="*", help="bench workload ids (default: all)")
     parser.add_argument("--ready-timeout", type=float, default=900)
     parser.add_argument("--max-load", type=float, default=2.0)
     parser.add_argument("--out", default=str(HERE / "results"))
diff --git a/benchmarks/laya_mps/profile_mps.py b/benchmarks/laya_mps/profile_mps.py
index c7a8ff5..82980e0 100644
--- a/benchmarks/laya_mps/profile_mps.py
+++ b/benchmarks/laya_mps/profile_mps.py
@@ -31,7 +31,7 @@
 
 HERE = Path(__file__).resolve().parent
 sys.path.insert(0, str(HERE))
-from env import header, noise_problems  # noqa: E402
+from env import header, read_workloads, refuse_if_noisy  # noqa: E402
 
 STAGES = ["encode", "collate", "dispatch", "gpu_wait", "copy_back", "decode", "other"]
 
@@ -81,7 +81,10 @@ def forward(b):
             if agent.device.type == "mps":
                 torch.mps.synchronize()
             t2 = time.perf_counter()
-            out = logits.float().cpu().numpy(), torch.softmax(act.float(), -1).cpu().numpy()
+            out = (
+                logits.float().cpu().numpy(),
+                torch.softmax(act.float(), -1).cpu().numpy(),
+            )
             t3 = time.perf_counter()
             self._add("dispatch", (t1 - t0) * 1000)
             self._add("gpu_wait", (t2 - t1) * 1000)
@@ -100,7 +103,9 @@ def request(self, state, questions):
             torch.mps.synchronize()
         stages, self.current = self.current, None
         stages["wall"] = (time.perf_counter() - started) * 1000
-        stages["other"] = stages["wall"] - sum(stages.get(s, 0.0) for s in STAGES if s != "other")
+        stages["other"] = stages["wall"] - sum(
+            stages.get(s, 0.0) for s in STAGES if s != "other"
+        )
         return stages, result
 
 
@@ -124,20 +129,17 @@ def main():
     parser.add_argument("--stage-workloads", nargs="+", default=["W1", "W3", "W5"])
     parser.add_argument("-n", type=int, default=100, help="timed requests per point")
     parser.add_argument("--discard", type=int, default=10)
-    parser.add_argument("--sweep-words", type=int, nargs="+", default=[1, 8, 24, 56, 120, 250, 380])
+    parser.add_argument(
+        "--sweep-words", type=int, nargs="+", default=[1, 8, 24, 56, 120, 250, 380]
+    )
     parser.add_argument("--ops-requests", type=int, default=20)
     parser.add_argument("--out", default=str(HERE / "results"))
     parser.add_argument("--max-load", type=float, default=2.0)
     args = parser.parse_args()
 
-    problems = noise_problems(args.max_load)
-    if problems and args.run != "feasibility":
-        sys.exit("refusing a measured run: " + "; ".join(problems))
-    for problem in problems:
-        print(f"warning: {problem}", file=sys.stderr)
+    problems = refuse_if_noisy(args.max_load, args.run != "feasibility")
 
-    with open(args.workloads) as f:
-        workloads = {w["id"]: w for w in (json.loads(line) for line in f if line.strip())}
+    workloads = read_workloads(args.workloads)
     route = workloads["W1"]["questions"]
 
     agent = laya.load(args.checkpoint, device=args.device)
@@ -187,12 +189,24 @@ def emit(record):
             )
             print(f"| {words} | {tokens} | {p50:.1f} |")
         a, b, r2 = fit([t for t, _ in points], [p for _, p in points])
-        emit({"type": "fit", "a_ms": round(a, 3), "b_ms_per_token": round(b, 5), "r2": round(r2, 4)})
+        emit(
+            {
+                "type": "fit",
+                "a_ms": round(a, 3),
+                "b_ms_per_token": round(b, 5),
+                "r2": round(r2, 4),
+            }
+        )
         print(f"\nwall ≈ {a:.1f} ms + {b:.3f} ms/token × tokens (R² {r2:.3f})")
 
         print("\n## Stages (median ms per request)\n")
         columns = ["wall", *STAGES, "gpu_exec"]
-        print("| workload | tokens | rows | " + " | ".join(columns) + " |\n|" + "---|" * (len(columns) + 3))
+        print(
+            "| workload | tokens | rows | "
+            + " | ".join(columns)
+            + " |\n|"
+            + "---|" * (len(columns) + 3)
+        )
         for wid in args.stage_workloads:
             w = workloads[wid]
             for _ in range(args.discard):
@@ -211,15 +225,21 @@ def emit(record):
                     "tokens": tokens,
                     "rows": len(w["questions"]),
                     "median_ms": {k: round(v, 3) for k, v in medians.items()},
-                    "samples": {k: [round(x, 3) for x in v] for k, v in per_stage.items()},
+                    "samples": {
+                        k: [round(x, 3) for x in v] for k, v in per_stage.items()
+                    },
                 }
             )
-            cells = " | ".join(f"{medians[c]:.1f}" if c in medians else "" for c in columns)
+            cells = " | ".join(
+                f"{medians[c]:.1f}" if c in medians else "" for c in columns
+            )
             print(f"| {wid} | {tokens} | {len(w['questions'])} | {cells} |")
 
         print("\n## Host operators for W1 (torch.profiler, CPU)\n")
         w = workloads["W1"]
-        with torch.profiler.profile(activities=[torch.profiler.ProfilerActivity.CPU]) as prof:
+        with torch.profiler.profile(
+            activities=[torch.profiler.ProfilerActivity.CPU]
+        ) as prof:
             for _ in range(args.ops_requests):
                 timer.request(w["state"], w["questions"])
         events = [e for e in prof.key_averages() if e.key.startswith("aten::")]
@@ -235,7 +255,9 @@ def emit(record):
                     {
                         "op": e.key,
                         "calls_per_request": e.count / args.ops_requests,
-                        "self_cpu_ms_per_request": e.self_cpu_time_total / 1000 / args.ops_requests,
+                        "self_cpu_ms_per_request": e.self_cpu_time_total
+                        / 1000
+                        / args.ops_requests,
                     }
                     for e in top
                 ],
diff --git a/benchmarks/laya_mps/release.py b/benchmarks/laya_mps/release.py
new file mode 100644
index 0000000..7193f5d
--- /dev/null
+++ b/benchmarks/laya_mps/release.py
@@ -0,0 +1,165 @@
+"""Releasing PyTorch's MPS caches: how much memory it gives back, and what it costs afterwards.
+
+In this process, prepared as the worker prepares a checkpoint (options, warmup, and an exit if the
+model is not on MPS): releases the caches with `torch.mps.empty_cache()` once, so that the baseline
+does not depend on what the warmup left cached, walks `--lengths` new one-question lengths as
+lengths.py does (each run twice in a row, stopping at the window), releases, runs the same lengths
+again and releases a second time. macOS shows a release in the footprint up to a few seconds later, so
+each footprint after a release is read `--settle` seconds after it. Prints the footprint at each step,
+and the extra time of a length's first request before and after the first release (a released length is
+cold again). The footprint at the start varies between runs by a few hundred MB even after a release;
+the footprint after a release does not.
+
+    python benchmarks/laya_mps/release.py --compile --weights fp16
+"""
+
+import argparse
+import json
+import statistics
+import sys
+import time
+import warnings
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+sys.path.insert(0, str(HERE.parents[1] / "src"))
+import lengths  # noqa: E402
+from env import footprint_mb, read_workloads, refuse_if_noisy  # noqa: E402
+
+
+def measure(run, footprint, release, first_words, step, count, settle_s):
+    """`run(words)` returns one request's ms and input tokens. After the first release nothing is warm."""
+
+    def released():
+        started = time.perf_counter()
+        release()
+        release_ms = (time.perf_counter() - started) * 1000
+        time.sleep(settle_s)
+        return footprint(), release_ms
+
+    records = []
+    before, _ = released()
+    measured = lengths.measure(
+        ["A"],
+        lambda _, words: run(words),
+        first_words,
+        step,
+        count,
+        set(),
+        records.append,
+    )
+    after_lengths = footprint()
+    after_release, release_ms = released()
+    after = [run(words)[0] - run(words)[0] for words, _ in measured]
+    after_rerun = footprint()
+    before_release = [
+        r["first_ms"] - r["again_ms"] for r in records if r["type"] == "length"
+    ]
+    walk = records[-1]
+    return {
+        "lengths": len(measured),
+        "stopped": walk["stopped"],
+        "longest_tokens": walk["longest_tokens"],
+        "footprint_mb": {
+            "before": before,
+            "after_lengths": after_lengths,
+            "after_release": after_release,
+            "after_rerun": after_rerun,
+            "after_second_release": released()[0],
+        },
+        "settle_s": settle_s,
+        "release_ms": round(release_ms, 1),
+        "extra_ms_before_release": round(statistics.median(before_release), 1)
+        if measured
+        else None,
+        "extra_ms_after_release": round(statistics.median(after), 1)
+        if measured
+        else None,
+    }
+
+
+def prepare(args):
+    """The worker's startup, in this process; exits if the model is not on MPS."""
+    from frontend.laya_mps import build_app, make_router
+
+    router = make_router("mps", args.model)
+    device = str(router.load(args.model).device)
+    if not device.startswith("mps"):
+        sys.exit(f"{args.model} is on {device}, not MPS")
+    build_app(
+        router,
+        args.model,
+        "mps",
+        require_device=False,
+        compile=args.compile,
+        fp16=args.weights == "fp16",
+    )
+    return router
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--compile", action="store_true", help="as frontend.laya_mps --compile"
+    )
+    parser.add_argument(
+        "--weights",
+        default="fp32",
+        choices=["fp32", "fp16"],
+        help="as the worker's flag",
+    )
+    parser.add_argument("--lengths", type=int, default=100)
+    parser.add_argument("--first-words", type=int, default=37)
+    parser.add_argument("--step", type=int, default=4)
+    parser.add_argument("--model", default="english")
+    parser.add_argument(
+        "--settle",
+        type=float,
+        default=3,
+        help="seconds between a release and reading the footprint",
+    )
+    parser.add_argument("--workloads", default=str(HERE / "workloads.jsonl"))
+    parser.add_argument("--max-load", type=float, default=2.0)
+    parser.add_argument(
+        "--feasibility",
+        action="store_true",
+        help="run on battery or under load anyway; the numbers are not measurements",
+    )
+    args = parser.parse_args()
+    problems = refuse_if_noisy(args.max_load, not args.feasibility)
+    warnings.filterwarnings("ignore")
+    import torch
+
+    question = read_workloads(args.workloads)["W1"]["questions"]
+    router = prepare(args)
+
+    def run(words):
+        started = time.perf_counter()
+        state = " ".join(["invoice"] * words)
+        result = router.predict(state, question, model=args.model)
+        return (time.perf_counter() - started) * 1000, result["usage"]["input_tokens"]
+
+    result = measure(
+        run,
+        lambda: footprint_mb()["footprint_mb"],
+        torch.mps.empty_cache,
+        args.first_words,
+        args.step,
+        args.lengths,
+        args.settle,
+    )
+    print(
+        json.dumps(
+            {
+                "compile": args.compile,
+                "weights": args.weights,
+                "noise": problems,
+                **result,
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/laya_mps/report.py b/benchmarks/laya_mps/report.py
index 4ec1aa8..8ba46c1 100644
--- a/benchmarks/laya_mps/report.py
+++ b/benchmarks/laya_mps/report.py
@@ -18,7 +18,13 @@
 from collections import defaultdict
 
 GATE = 0.10
-PHASES = ["import_s", "load_s", "process_to_ready_s", "warmup_s"]  # whichever a result file has
+# whichever a result file has
+PHASES = [
+    "import_s",
+    "load_s",
+    "process_to_ready_s",
+    "warmup_s",
+]
 
 
 def percentile(sorted_values, p):
@@ -30,8 +36,12 @@ def read(paths):
     for path in paths:
         with open(path) as f:
             rows = [json.loads(line) for line in f if line.strip()]
-        if any("config" not in r for r in rows):  # e.g. paired.py results: summarize those with paired.py
-            print(f"skipping {path}: not a bench_inproc/bench_http result", file=sys.stderr)
+        # e.g. paired.py results: summarize those with paired.py
+        if any("config" not in r for r in rows):
+            print(
+                f"skipping {path}: not a bench_inproc/bench_http result",
+                file=sys.stderr,
+            )
             continue
         records.extend(rows)
     return records
@@ -39,7 +49,10 @@ def read(paths):
 
 def table(headers, rows):
     lines = ["| " + " | ".join(headers) + " |", "|" + "---|" * len(headers)]
-    lines += ["| " + " | ".join("" if c is None else str(c) for c in row) + " |" for row in rows]
+    lines += [
+        "| " + " | ".join("" if c is None else str(c) for c in row) + " |"
+        for row in rows
+    ]
     return "\n".join(lines)
 
 
@@ -84,13 +97,24 @@ def environment(envs):
 
 
 def phase_table(phases):
-    present = [p for p in PHASES if any(ph.get(p) is not None for ph in phases.values())]
+    present = [
+        p for p in PHASES if any(ph.get(p) is not None for ph in phases.values())
+    ]
     workload_ids = sorted({w for ph in phases.values() for w in ph["first_ms"]})
     rows = [
-        [*k, *(ph.get(p) for p in present), *(ph["first_ms"].get(w) for w in workload_ids)]
+        [
+            *k,
+            *(ph.get(p) for p in present),
+            *(ph["first_ms"].get(w) for w in workload_ids),
+        ]
         for k, ph in sorted(phases.items())
     ]
-    headers = ["config", "run", *(p.removesuffix("_s") for p in present), *(f"first {w}" for w in workload_ids)]
+    headers = [
+        "config",
+        "run",
+        *(p.removesuffix("_s") for p in present),
+        *(f"first {w}" for w in workload_ids),
+    ]
     return table(headers, rows)
 
 
@@ -98,7 +122,9 @@ def latency(records):
     samples = defaultdict(list)
     for r in records:
         if r["type"] == "req" and r.get("status", 200) == 200:
-            samples[(r["config"], r["workload"], r.get("concurrency", 1), r["run"])].append(r["wall_ms"])
+            samples[
+                (r["config"], r["workload"], r.get("concurrency", 1), r["run"])
+            ].append(r["wall_ms"])
     rows, p50s = [], defaultdict(dict)
     for (config, workload, concurrency, run), values in sorted(samples.items()):
         values.sort()
@@ -120,27 +146,68 @@ def latency(records):
                 f"{cv:.1%}",
             ]
         )
-    return table(["config", "workload", "conc", "run", "n", "p50", "p95", "mean", "CV"], rows), p50s
+    return table(
+        ["config", "workload", "conc", "run", "n", "p50", "p95", "mean", "CV"], rows
+    ), p50s
 
 
 def gate(p50s):
     rows = []
     for (config, workload, concurrency), by_run in sorted(p50s.items()):
         if len(by_run) < 2:
-            rows.append([config, workload, concurrency, len(by_run), "", "needs 2 measured runs"])
+            rows.append(
+                [
+                    config,
+                    workload,
+                    concurrency,
+                    len(by_run),
+                    "",
+                    "needs 2 measured runs",
+                ]
+            )
             continue
         spread = (max(by_run.values()) - min(by_run.values())) / min(by_run.values())
-        rows.append([config, workload, concurrency, len(by_run), f"{spread:.1%}", "PASS" if spread <= GATE else "FAIL"])
+        rows.append(
+            [
+                config,
+                workload,
+                concurrency,
+                len(by_run),
+                f"{spread:.1%}",
+                "PASS" if spread <= GATE else "FAIL",
+            ]
+        )
     return table(["config", "workload", "conc", "runs", "spread", "gate"], rows)
 
 
 def throughput(records):
     rows = [
-        [r["config"], r["workload"], r["concurrency"], r["run"], r["n"], r["errors"], r["elapsed_s"], r["rps"]]
+        [
+            r["config"],
+            r["workload"],
+            r["concurrency"],
+            r["run"],
+            r["n"],
+            r["errors"],
+            r["elapsed_s"],
+            r["rps"],
+        ]
         for r in records
         if r["type"] == "throughput"
     ]
-    return table(["config", "workload", "conc", "run", "n", "errors", "elapsed s", "successful req/s"], sorted(rows))
+    return table(
+        [
+            "config",
+            "workload",
+            "conc",
+            "run",
+            "n",
+            "errors",
+            "elapsed s",
+            "successful req/s",
+        ],
+        sorted(rows),
+    )
 
 
 def memory(phases, ends):
@@ -189,7 +256,9 @@ def read_answers(records):
         elif r["type"] == "answers":
             answers.setdefault(key, {})[r["workload"]] = r["answers"]
         elif r["type"] == "answers_error":
-            errors.setdefault(key, {})[r["workload"]] = f"status {r.get('status')}: {r.get('detail')}"
+            errors.setdefault(key, {})[r["workload"]] = (
+                f"status {r.get('status')}: {r.get('detail')}"
+            )
     return envs, answers, errors, benchmarks
 
 
@@ -236,7 +305,8 @@ def parity(records, ref):
         "|---|---|---|---|---|---|---|---|---|---|",
     ]
     failed = total = 0
-    for key in sorted(benchmarks | answers.keys() | errors.keys()):  # a benchmark run without answers still counts
+    # a benchmark run without answers still counts
+    for key in sorted(benchmarks | answers.keys() | errors.keys()):
         if key == ref_key:
             continue
         env = envs.get(key, {})
@@ -244,7 +314,9 @@ def parity(records, ref):
             got = answers.get(key, {}).get(workload)
             if got is None:
                 why = errors.get(key, {}).get(workload, "missing")
-                lines.append(f"| {key[0]} | {key[1]} | {workload} | | | | {why} | | | FAIL |")
+                lines.append(
+                    f"| {key[0]} | {key[1]} | {workload} | | | | {why} | | | FAIL |"
+                )
                 failed += 1
                 total += 1
                 continue
@@ -252,15 +324,24 @@ def parity(records, ref):
             for qid, ref_answer in sorted(questions.items()):
                 total += 1
                 if qid not in got:
-                    lines.append(f"| {key[0]} | {key[1]} | {workload} | {qid} | | | missing | | | FAIL |")
+                    lines.append(
+                        f"| {key[0]} | {key[1]} | {workload} | {qid} | | | missing | | | FAIL |"
+                    )
                     failed += 1
                     continue
                 ref_decision, ref_probs = outcome(ref_answer)
                 decision, probs = outcome(got[qid])
-                delta = max(abs(ref_probs.get(o, 0.0) - probs.get(o, 0.0)) for o in ref_probs.keys() | probs.keys())
+                delta = max(
+                    abs(ref_probs.get(o, 0.0) - probs.get(o, 0.0))
+                    for o in ref_probs.keys() | probs.keys()
+                )
                 ok = decision == ref_decision and delta <= TOLERANCE[precision]
                 failed += not ok
-                flip = f"{ref_decision} → {decision}" if decision != ref_decision else f"{decision}"
+                flip = (
+                    f"{ref_decision} → {decision}"
+                    if decision != ref_decision
+                    else f"{decision}"
+                )
                 lines.append(
                     f"| {key[0]} | {key[1]} | {workload} | {qid} | {ref_answer['type']} | {precision} | {flip} "
                     f"| {delta:.4f} | {margin(ref_probs):.4f} | {'PASS' if ok else 'FAIL'} |"
@@ -272,7 +353,11 @@ def parity(records, ref):
 def main():
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     parser.add_argument("files", nargs="+")
-    parser.add_argument("--ref", default="C1", help="reference config for the parity section (default C1)")
+    parser.add_argument(
+        "--ref",
+        default="C1",
+        help="reference config for the parity section (default C1)",
+    )
     args = parser.parse_args()
     records = read(args.files)
 
@@ -282,9 +367,14 @@ def by_run(kind):
     envs, phases, ends = by_run("env"), by_run("phase"), by_run("end")
     latency_table, p50s = latency(records)
     print("## Environment\n\n" + environment(envs))
-    print("\n## Phases (s) and first request per workload (ms)\n\n" + phase_table(phases))
+    print(
+        "\n## Phases (s) and first request per workload (ms)\n\n" + phase_table(phases)
+    )
     print("\n## Warm latency (ms)\n\n" + latency_table)
-    print(f"\n## Run-to-run gate (p50 spread across measured runs <= {GATE:.0%})\n\n" + gate(p50s))
+    print(
+        f"\n## Run-to-run gate (p50 spread across measured runs <= {GATE:.0%})\n\n"
+        + gate(p50s)
+    )
     if any(r["type"] == "throughput" for r in records):
         print("\n## Throughput\n\n" + throughput(records))
     print("\n## Memory (MB)\n\n" + memory(phases, ends))
diff --git a/recipe/laya/apple-silicon.md b/recipe/laya/apple-silicon.md
index 1344ea1..a779de9 100644
--- a/recipe/laya/apple-silicon.md
+++ b/recipe/laya/apple-silicon.md
@@ -7,7 +7,9 @@ runs the benchmarks. The model-side code is in [`src/models/laya/`](../../src/mo
 
 Validated on an M1 Pro (16 GB, 16-core GPU), macOS 26.1, Python 3.12, `laya[serve]==0.3.20`,
 torch 2.14.0 and the `english` checkpoint (`convaiinnovations/laya` at `55cf4c4`), and by another
-contributor on an M5 (10-core GPU, 32 GB, macOS 26.5.2). Other M-series Macs have not been tested.
+contributor on an M5 (10-core GPU, 32 GB, macOS 26.5.2). A reviewer ran the tests on an M4 (10-core GPU,
+16 GB, macOS 26, Python 3.13), including the contract tests on the GPU. Other M-series Macs have not been
+tested.
 
 Run all commands from the repository root.
 
@@ -33,9 +35,11 @@ PYTHONPATH=src .venv/bin/python -m frontend.laya_mps --device mps --model englis
 First startup downloads the checkpoint (846 MB; 97 s into an empty cache at 8.7 MB/s when measured). The
 worker loads the model, runs a warmup
 over short, long and multi-question requests, and only then listens on port 8000, so the first
-request it accepts is already warm: on an M1 Pro the first request after ready took 70–81 ms, against
-0.7–1.1 s from plain laya-serve. `--require-device` makes it exit instead of silently serving on the CPU
-when the model cannot be placed on MPS; without it the worker logs a warning and serves from the CPU.
+request it accepts is already warm: on an M1 Pro the first request after ready took 67–81 ms. Plain
+laya-serve's first request took 0.7–1.1 s in three runs and 0.2–0.4 s in seven later fresh starts, with
+the same versions; what changed is not known (not the GPU's state left by the previous run).
+`--require-device` makes it exit instead of silently serving on the CPU when the model cannot be placed
+on MPS; without it the worker logs a warning and serves from the CPU.
 Of laya-serve's environment variables, `LAYA_API_KEY` (bearer authentication) still applies. Those its
 launcher reads do not: device, model, host, port and log level are the flags above, and `LAYA_THREADS` and
 `LAYA_AUTO_TASK` are not read. The worker warns at startup if any of them is set.
@@ -43,11 +47,11 @@ launcher reads do not: device, model, host, port and log level are the flags abo
 Laya loads another checkpoint when a request names it (`"model": "multilingual"`) or its routing picks it
 (a non-English state). The worker prepares that checkpoint the same way inside that first request; other
 requests wait behind it, `/health` names it under `preparing` meanwhile and lists it afterwards. On the
-M1 Pro that first request took about 5–10 s without the options and about 70 s with `--compile` (plus the
-download the first time, 680 MB for `multilingual`). The frontend gives a backend 60 s, so with `--compile`
-it answered that request with 504 while the worker finished preparing; the same request sent again then
-took 35 ms. To avoid that, send one request for each further checkpoint straight to the worker after
-startup. Each resident checkpoint needs its own memory (see Troubleshooting).
+M1 Pro that first request took 5–10 s without the options and 19–22 s with `--compile` (plus the download
+the first time, 680 MB for `multilingual`). The frontend gives a backend 60 s: a load that takes longer
+is answered with 504 while the worker finishes preparing, and the same request sent again is fast. To be
+safe, send one request for each further checkpoint straight to the worker after startup. Each resident
+checkpoint needs its own memory (see Troubleshooting).
 
 With `--require-device`, a checkpoint that does not land on the requested device is unloaded again and
 the request fails with 500. If Laya evicted another checkpoint to make room for it (it keeps two by
@@ -65,7 +69,7 @@ dtype Laya uses for requests with at least `mps_amp_min_rows` questions, and the
 and dtypes are read on every call: if a request runs out of GPU memory, Laya moves the model to the CPU
 and keeps serving, and `/health` then shows `device: cpu` and `device_mismatch: true`. Triggered on the
 M1 Pro by lowering PyTorch's MPS memory limit: the request that ran out of memory still returned 200
-after about 30 s, and later 68-token requests took 140–270 ms from the CPU.
+after 30–73 s, and later 68-token requests took 140–270 ms from the CPU.
 
 ### Faster: compile and fp16 weights
 
@@ -100,16 +104,17 @@ The latencies above are for requests sent back to back. Measured on the M1 Pro:
   has slowed down in the meantime. For a short one-question request (25 ms back to back with the options,
   40 ms without) it took about 50 ms after 0.2–1 s of idle and 105–115 ms after 2–5 s (60–68 ms and
   114–127 ms without the options). This is also why the first request after ready costs more than a warm
-  one. An agent that asks once every few seconds sees these numbers, not the back-to-back ones. A
-  heartbeat of one forward pass every 0.5 s held it at about 45 ms in a probe, for 8% GPU load; the worker
-  does not do this.
+  one. An agent that asks once every few seconds sees these numbers, not the back-to-back ones. Keeping
+  the GPU busy between requests would avoid it, at the cost of power; the worker does not do this.
 - **New input lengths.** The first request of a length the worker has not seen costs about 15 ms more
   once with the options (6 ms without). It is not a recompile (`recompiled_after_ready` stays `false`).
 - **Memory grows with the lengths seen.** With `--compile`, PyTorch keeps host memory for every input
   length the compiled model has run, about 5 MB each (fp16 weights alone add little): the 3 GB above became
-  3.3 GB after 100 new lengths and 5.3 GB after all 477, more than the 4.0 GB of a worker without the
-  options. `torch.mps.empty_cache()` releases most of it, and those lengths then pay their first-request
-  cost again.
+  3.3 GB after 100 new lengths and 5.2 GB after all 454 that the benchmark's one-question request can
+  take (57–512 tokens), more than the 3.7 GB of a worker without the options. `torch.mps.empty_cache()`
+  gives it back: with the model in one process and no HTTP server, a release brought the footprint to
+  2.95 GB in three runs however much the lengths had added, and to 2.90 GB after running the same lengths
+  again and releasing again. Those lengths then pay their first-request cost again.
 
 `/health` reports under `compile` how many graphs existed when the worker became ready and how many
 exist now; `recompiled_after_ready: true` means a request shape was not covered by the warmup.
@@ -142,12 +147,15 @@ The frontend forwards the worker's response unchanged; `compare_with_backend.py`
 
 ## Test
 
-The tests need `pytest` and `httpx2` (Starlette's `TestClient`; `httpx` works with a deprecation warning):
+The tests need `pytest` and `httpx2` (Starlette's `TestClient`; `httpx` works with a deprecation warning);
+`requirements-mps.txt` pins them and ruff:
 
 ```sh
-.venv/bin/python -m pip install pytest httpx2
+.venv/bin/python -m pip install -r recipe/laya/requirements-mps.txt
 PYTHONPATH=src .venv/bin/python -m pytest tests/laya                    # unit tests, no model
 LAYA_CONTRACT=1 PYTHONPATH=src .venv/bin/python -m pytest tests/laya    # plus contract tests against a CPU worker
+.venv/bin/ruff format --check src/frontend/laya_mps.py src/models/laya benchmarks/laya_mps tests/laya
+.venv/bin/ruff check --select E4,E7,E9,F src/frontend/laya_mps.py src/models/laya benchmarks/laya_mps tests/laya
 ```
 
 The contract tests start a real worker and check readiness, the three decision types, error responses, and
@@ -163,7 +171,8 @@ LAYA_CONTRACT=1 LAYA_CONTRACT_DEVICE=mps LAYA_CONTRACT_FLAGS="--compile --weight
 ## Benchmark
 
 Stop the worker and frontend first; the benchmark starts its own. The scripts are listed in
-[`benchmarks/laya_mps/`](../../benchmarks/laya_mps/README.md). A first pass that checks everything runs:
+[`benchmarks/laya_mps/`](../../benchmarks/laya_mps/README.md), which also lists the command behind each
+number in this recipe. A first pass that checks everything runs:
 
 ```sh
 .venv/bin/python benchmarks/laya_mps/bench_inproc.py --device mps --config C2 --run feasibility
diff --git a/recipe/laya/requirements-mps.txt b/recipe/laya/requirements-mps.txt
index dca8e7a..0fe46fd 100644
--- a/recipe/laya/requirements-mps.txt
+++ b/recipe/laya/requirements-mps.txt
@@ -8,3 +8,7 @@ safetensors==0.8.0
 huggingface-hub==1.33.0
 fastapi==0.141.1
 uvicorn==0.54.0
+# For the tests and checks in the recipe's Test section.
+pytest==9.1.1
+httpx2==2.13.1
+ruff==0.16.10
diff --git a/src/frontend/laya_mps.py b/src/frontend/laya_mps.py
index c29eda4..7af2c1b 100644
--- a/src/frontend/laya_mps.py
+++ b/src/frontend/laya_mps.py
@@ -72,22 +72,31 @@ def build_app(
     nothing is preloaded. Raises if preparing fails, so the caller never binds a worker that cannot answer."""
     from laya.serve import create_app
 
-    resident: dict[str, tuple[Any, dict[str, Any]]] = {}  # prepared checkpoints: name -> (agent, warmup result)
+    # prepared checkpoints: name -> (agent, warmup result)
+    resident: dict[str, tuple[Any, dict[str, Any]]] = {}
     preparing: set[str] = set()
     graphs_at_ready = None
 
     def apply_options(name: str, agent: Any) -> None:
         if (fp16 or compile) and not optimize.apply(agent, fp16=fp16, compile=compile):
-            log.warning("%s is on the CPU: --compile and --weights fp16 apply on the GPU only", name)
+            log.warning(
+                "%s is on the CPU: --compile and --weights fp16 apply on the GPU only",
+                name,
+            )
 
     def make_ready(name: str, agent: Any) -> str | None:
         """Warm the checkpoint up and start describing it. Returns where it is if not on the requested device."""
         nonlocal graphs_at_ready
         warmed = engine.warmup(router, name)
-        warmed["revision"] = engine.loaded_revision(revisions, warmed["routing"])  # fixed here: see engine
+        # fixed here: see engine
+        warmed["revision"] = engine.loaded_revision(revisions, warmed["routing"])
         resident[name] = (agent, warmed)
         autocast_rows = getattr(agent, "mps_amp_min_rows", None)
-        if str(agent.device).startswith("mps") and autocast_rows and autocast_rows > engine.WARMUP_MAX_ROWS:
+        if (
+            str(agent.device).startswith("mps")
+            and autocast_rows
+            and autocast_rows > engine.WARMUP_MAX_ROWS
+        ):
             log.warning(
                 "%s: laya autocasts from %d questions but the warmup stops at %d; the first request that "
                 "large is not warm",
@@ -97,8 +106,14 @@ def make_ready(name: str, agent: Any) -> str | None:
             )
         if compile:
             graphs_at_ready = graph_counter()
-        described = engine.describe(agent, requested, warmed["routing"], warmed["revision"])
-        return f"{name} is on {described['device']}" if described["device_mismatch"] else None
+        described = engine.describe(
+            agent, requested, warmed["routing"], warmed["revision"]
+        )
+        return (
+            f"{name} is on {described['device']}"
+            if described["device_mismatch"]
+            else None
+        )
 
     def check_device(misplaced: list[str]) -> None:
         if misplaced:
@@ -107,7 +122,8 @@ def check_device(misplaced: list[str]) -> None:
                 raise RuntimeError(message)
             log.warning(message)
 
-    evicted: list[str] = []  # what laya dropped to make room for the checkpoint it is loading
+    # what laya dropped to make room for the checkpoint it is loading
+    evicted: list[str] = []
 
     def on_evict(ctx: Any) -> None:
         resident.pop(ctx.model, None)
@@ -131,18 +147,26 @@ def on_load(ctx: Any) -> None:
                 try:
                     router.load(name)
                 except Exception:  # noqa: BLE001 -- the request fails for the first reason either way
-                    log.exception("%s was evicted for %s and could not be loaded again", name, ctx.model)
+                    log.exception(
+                        "%s was evicted for %s and could not be loaded again",
+                        name,
+                        ctx.model,
+                    )
             if compile:
-                graphs_at_ready = graph_counter()  # graphs the unloaded checkpoint compiled are not recompiles
+                # graphs the unloaded checkpoint compiled are not recompiles
+                graphs_at_ready = graph_counter()
             raise
         finally:
             preparing.discard(ctx.model)
 
-    names = list(router.loaded) or [model]  # never load a model the worker was not asked to serve
+    # never load a model the worker was not asked to serve
+    names = list(router.loaded) or [model]
     startup = {name: router.load(name) for name in names}
     for name, agent in startup.items():
         apply_options(name, agent)
-    check_device(list(filter(None, [make_ready(name, agent) for name, agent in startup.items()])))
+    check_device(
+        list(filter(None, [make_ready(name, agent) for name, agent in startup.items()]))
+    )
     for hook in [h for h in getattr(router, "hooks", ()) if isinstance(h, Lifecycle)]:
         router.remove_hook(hook)  # an app built earlier on this router
     router.add_hook(Lifecycle(on_load, on_evict))
@@ -151,7 +175,9 @@ def current() -> dict[str, Any]:
         """The agents as they are now, not as they were at startup (see the module docstring)."""
         models = {
             name: {
-                **engine.describe(agent, requested, warmed["routing"], warmed["revision"]),
+                **engine.describe(
+                    agent, requested, warmed["routing"], warmed["revision"]
+                ),
                 "warmup_ms": warmed["warmup_ms"],
             }
             for name, (agent, warmed) in list(resident.items())
@@ -164,7 +190,9 @@ def current() -> dict[str, Any]:
         }
 
     app = create_app(router)
-    app.router.routes[:] = [r for r in app.router.routes if getattr(r, "path", None) != "/health"]
+    app.router.routes[:] = [
+        r for r in app.router.routes if getattr(r, "path", None) != "/health"
+    ]
 
     @app.get("/health")
     def health() -> dict[str, Any]:
@@ -172,7 +200,10 @@ def health() -> dict[str, Any]:
         if compile:
             now = graph_counter()
             compiled.update(
-                active=any(optimize.compile_active(agent) for agent, _ in list(resident.values())),
+                active=any(
+                    optimize.compile_active(agent)
+                    for agent, _ in list(resident.values())
+                ),
                 graphs_at_ready=graphs_at_ready,
                 graphs_now=now,
                 recompiled_after_ready=now > graphs_at_ready and not preparing,
@@ -199,11 +230,32 @@ def make_router(device: str | None, model: str) -> Any:
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--device", default=None, help="torch device for laya: mps, cpu (default: laya's choice)")
-    parser.add_argument("--model", default="english", help="laya checkpoint to serve: english, multilingual, ...")
-    parser.add_argument("--compile", action="store_true", help="torch.compile the GPU path during warmup")
-    parser.add_argument("--weights", default="fp32", choices=["fp32", "fp16"], help="weight precision on the GPU")
-    parser.add_argument("--require-device", action="store_true", help="exit if a model is not on --device")
+    parser.add_argument(
+        "--device",
+        default=None,
+        help="torch device for laya: mps, cpu (default: laya's choice)",
+    )
+    parser.add_argument(
+        "--model",
+        default="english",
+        help="laya checkpoint to serve: english, multilingual, ...",
+    )
+    parser.add_argument(
+        "--compile",
+        action="store_true",
+        help="torch.compile the GPU path during warmup",
+    )
+    parser.add_argument(
+        "--weights",
+        default="fp32",
+        choices=["fp32", "fp16"],
+        help="weight precision on the GPU",
+    )
+    parser.add_argument(
+        "--require-device",
+        action="store_true",
+        help="exit if a model is not on --device",
+    )
     parser.add_argument("--host", default="127.0.0.1")
     parser.add_argument("--port", type=int, default=8000)
     parser.add_argument(
@@ -219,7 +271,10 @@ def main() -> None:
     logging.basicConfig(level=args.log_level.upper(), format="%(name)s: %(message)s")
     unread = [name for name in UNREAD_LAYA_SERVE_VARIABLES if os.environ.get(name)]
     if unread:
-        log.warning("%s: read by laya-serve's launcher, not by this worker; use the flags", ", ".join(unread))
+        log.warning(
+            "%s: read by laya-serve's launcher, not by this worker; use the flags",
+            ", ".join(unread),
+        )
     revisions = engine.record_snapshot_revisions()
     try:
         app = build_app(
diff --git a/src/models/laya/engine.py b/src/models/laya/engine.py
index 2ec8cd5..586b7a4 100644
--- a/src/models/laya/engine.py
+++ b/src/models/laya/engine.py
@@ -15,22 +15,38 @@
 _CHOICE = {
     "type": "choice",
     "instructions": "Which team should handle this?",
-    "criteria": {"billing": "Charges and refunds", "technical": "Software problems", "other": "Anything else"},
+    "criteria": {
+        "billing": "Charges and refunds",
+        "technical": "Software problems",
+        "other": "Anything else",
+    },
+}
+_SCORE = {
+    "type": "score",
+    "instructions": "How urgent is it?",
+    "criteria": ["Low", "Medium", "High"],
 }
-_SCORE = {"type": "score", "instructions": "How urgent is it?", "criteria": ["Low", "Medium", "High"]}
 _NOUL = {"type": "noul", "instructions": "Does the customer ask for a refund?"}
 WARMUP_SHAPES = [
     (10, {"q": _CHOICE}),
     (150, {"q": _CHOICE}),
     (400, {"q": _CHOICE}),
     (10, {"a": _CHOICE, "b": _SCORE, "c": _NOUL}),
-    (10, {f"q{i}": q for i, q in enumerate([_CHOICE, _SCORE, _NOUL, _CHOICE, _SCORE, _NOUL])}),
+    (
+        10,
+        {
+            f"q{i}": q
+            for i, q in enumerate([_CHOICE, _SCORE, _NOUL, _CHOICE, _SCORE, _NOUL])
+        },
+    ),
 ]
 WARMUP_REPEATS = 2
 WARMUP_MAX_ROWS = max(len(questions) for _, questions in WARMUP_SHAPES)
 
 
-def warmup(router: Any, model: str, shapes=WARMUP_SHAPES, repeats: int = WARMUP_REPEATS) -> dict[str, Any]:
+def warmup(
+    router: Any, model: str, shapes=WARMUP_SHAPES, repeats: int = WARMUP_REPEATS
+) -> dict[str, Any]:
     """Any failure propagates: a worker that cannot answer must not bind."""
     started = time.perf_counter()
     routing = None
@@ -39,13 +55,20 @@ def warmup(router: Any, model: str, shapes=WARMUP_SHAPES, repeats: int = WARMUP_
         for _ in range(repeats):
             result = router.predict(state, questions, model=model)
             routing = result.get("routing") or routing
-    return {"warmup_ms": round((time.perf_counter() - started) * 1000, 1), "routing": routing}
+    return {
+        "warmup_ms": round((time.perf_counter() - started) * 1000, 1),
+        "routing": routing,
+    }
 
 
 def _checkpoint_name(repo_id: str, allow_patterns: Any) -> str:
     """laya's name for what one download fetched: "<repo>", or "<repo>/<subfolder>" for a bundled checkpoint.
     laya restricts each download to one checkpoint's files, which all sit under its subfolder if it has one."""
-    patterns = [allow_patterns] if isinstance(allow_patterns, str) else list(allow_patterns or [""])
+    patterns = (
+        [allow_patterns]
+        if isinstance(allow_patterns, str)
+        else list(allow_patterns or [""])
+    )
     folders = {pattern.split("/")[0] if "/" in pattern else "" for pattern in patterns}
     subfolder = folders.pop() if len(folders) == 1 else ""
     return f"{repo_id}/{subfolder}" if subfolder else repo_id
@@ -78,13 +101,18 @@ def recording(repo_id, *args, **kwargs):
     return revisions
 
 
-def loaded_revision(revisions: dict[str, str] | None, routing: dict[str, Any] | None) -> str | None:
+def loaded_revision(
+    revisions: dict[str, str] | None, routing: dict[str, Any] | None
+) -> str | None:
     """The commit of the checkpoint that has just loaded, if it was downloaded."""
     return (revisions or {}).get((routing or {}).get("repo"))
 
 
 def describe(
-    agent: Any, requested: str | None, routing: dict[str, Any] | None, revision: str | None = None
+    agent: Any,
+    requested: str | None,
+    routing: dict[str, Any] | None,
+    revision: str | None = None,
 ) -> dict[str, Any]:
     """What /health reports about one loaded agent, read from the agent as it is now."""
     device = str(getattr(agent, "device", "unknown"))
@@ -98,7 +126,8 @@ def describe(
     return {
         "device": device,
         "requested_device": requested or "auto",
-        "device_mismatch": bool(requested_type) and device.split(":")[0] != requested_type,
+        "device_mismatch": bool(requested_type)
+        and device.split(":")[0] != requested_type,
         "weights_dtype": weights,
         "autocast_dtype": str(getattr(agent, "dtype", None)),
         "mps_amp_min_rows": getattr(agent, "mps_amp_min_rows", None),
diff --git a/src/models/laya/optimize.py b/src/models/laya/optimize.py
index 2b6d369..d02d4c0 100644
--- a/src/models/laya/optimize.py
+++ b/src/models/laya/optimize.py
@@ -32,7 +32,9 @@ def forward(self, input_ids, *args, **kwargs):
             if self.paths is None:
                 return self.eager(input_ids, *args, **kwargs)
             whole, encoder_only = self.paths
-            return (whole if input_ids.shape[0] == 1 else encoder_only)(input_ids, *args, **kwargs)
+            return (whole if input_ids.shape[0] == 1 else encoder_only)(
+                input_ids, *args, **kwargs
+            )
 
     return Served
 
@@ -102,7 +104,9 @@ def apply(agent: Any, *, fp16: bool, compile: bool) -> bool:
 
 def compile_active(agent: Any) -> bool:
     """Whether requests to this agent run the compiled paths now. False on the CPU, also after a fallback."""
-    return getattr(getattr(agent, "model", None), "paths", None) is not None and not _on_cpu(agent)
+    return getattr(
+        getattr(agent, "model", None), "paths", None
+    ) is not None and not _on_cpu(agent)
 
 
 def compiled_graphs() -> int:
diff --git a/tests/laya/test_bench.py b/tests/laya/test_bench.py
index 9baa7a1..13b4a59 100644
--- a/tests/laya/test_bench.py
+++ b/tests/laya/test_bench.py
@@ -1,6 +1,8 @@
 """Checks on the benchmark inputs, the run header and the documented commands in recipe/laya. No model."""
 
 import json
+
+import pytest
 import subprocess
 import sys
 from pathlib import Path
@@ -18,8 +20,14 @@ def rows(path):
 
 def test_header_records_what_makes_two_runs_comparable(monkeypatch):
     record = bench_env.header("some/repo", extra=1)
-    assert record["type"] == "env" and record["extra"] == 1 and record["checkpoint"] == "some/repo"
-    head = subprocess.run(["git", "-C", str(REPO), "rev-parse", "HEAD"], capture_output=True, text=True).stdout.strip()
+    assert (
+        record["type"] == "env"
+        and record["extra"] == 1
+        and record["checkpoint"] == "some/repo"
+    )
+    head = subprocess.run(
+        ["git", "-C", str(REPO), "rev-parse", "HEAD"], capture_output=True, text=True
+    ).stdout.strip()
     assert record["omni_sha"] == head and isinstance(record["omni_dirty"], bool)
     import laya  # noqa: F401
     from importlib.metadata import version
@@ -27,9 +35,12 @@ def test_header_records_what_makes_two_runs_comparable(monkeypatch):
     assert (record["laya"], record["torch"], record["transformers"]) == tuple(
         version(package) for package in ("laya", "torch", "transformers")
     )
-    assert record["argv"] == sys.argv and record["python"] == ".".join(map(str, sys.version_info[:3]))
+    assert record["argv"] == sys.argv and record["python"] == ".".join(
+        map(str, sys.version_info[:3])
+    )
     assert record["loadavg_1m"] >= 0
-    if sys.platform == "darwin":  # the machine probes use macOS tools; elsewhere they are None (test below)
+    # the machine probes use macOS tools; elsewhere they are None (test below)
+    if sys.platform == "darwin":
         assert record["power"] and record["chip"] and record["mem_gb"] > 0
     assert record["utc"].endswith("+00:00")
 
@@ -39,62 +50,108 @@ def test_the_fixed_inputs_span_question_types_lengths_and_option_counts():
     assert len({w["id"] for w in workloads}) == len(workloads)
     questions = [q for w in workloads for q in w["questions"].values()]
     assert {q["type"] for q in questions} == {"choice", "score", "noul"}
-    assert {len(q["criteria"]) for q in questions if q["type"] == "choice"} >= {2, 5, 10}
+    assert {len(q["criteria"]) for q in questions if q["type"] == "choice"} >= {
+        2,
+        5,
+        10,
+    }
     bench = [w for w in workloads if w["kind"] == "bench"]
     words = sorted(len(w["state"].split()) for w in bench)
-    assert (
-        words[0] < 20 and 100 < max(w for w in words if w < 200) and words[-1] > 300
-    )  # short, medium, near the window
-    assert {len(w["questions"]) for w in bench} >= {1, 3, 6}  # below and above laya's autocast threshold of 5 rows
+    # short, medium, near the window
+    assert words[0] < 20 and 100 < max(w for w in words if w < 200) and words[-1] > 300
+    # below and above laya's autocast threshold of 5 rows
+    assert {len(w["questions"]) for w in bench} >= {
+        1,
+        3,
+        6,
+    }
     parity = [w for w in workloads if w["kind"] == "parity"]
-    assert {q["type"] for w in parity for q in w["questions"].values()} == {"choice", "score", "noul"}
-
-
-DOCUMENTS = ["recipe/laya/apple-silicon.md", "benchmarks/laya_mps/README.md", "src/models/laya/README.md"]
+    assert {q["type"] for w in parity for q in w["questions"].values()} == {
+        "choice",
+        "score",
+        "noul",
+    }
+
+
+DOCUMENTS = [
+    "recipe/laya/apple-silicon.md",
+    "benchmarks/laya_mps/README.md",
+    "src/models/laya/README.md",
+]
+BENCH_SCRIPTS = (
+    "bench_http",
+    "bench_inproc",
+    "paired",
+    "profile_mps",
+    "report",
+    "lengths",
+)
+BENCH_SCRIPTS += ("late_load", "fallback", "release")
 SCRIPTS = {
     "frontend.laya_mps": "src/frontend/laya_mps.py",
-    **{f"benchmarks/laya_mps/{name}.py": f"benchmarks/laya_mps/{name}.py"
-       for name in ("bench_http", "bench_inproc", "paired", "profile_mps", "report")},
-}  # fmt: skip
+    **{f"{name}.py": f"benchmarks/laya_mps/{name}.py" for name in BENCH_SCRIPTS},
+}
 
 
 def documented_commands():
+    """Commands in sh blocks, and inline ones in tables such as the reproduction index."""
     import re
 
     for document in DOCUMENTS:
         text = (REPO / document).read_text()
+        lines = []
         for block in re.findall(r"```sh\n(.*?)```", text, flags=re.S):
-            for command in block.replace("\\\n", " ").splitlines():
-                for name, source in SCRIPTS.items():
-                    if name in command:
-                        yield document, command, name, source
+            lines += block.replace("\\\n", " ").splitlines()
+        prose = re.sub(r"```.*?```", "", text, flags=re.S)
+        lines += re.findall(r"`([^`\n]*\.py --[^`\n]*)`", prose)
+        for command in lines:
+            for name, source in SCRIPTS.items():
+                if re.search(rf"(^|[/ ]){re.escape(name)}( |$)", command):
+                    yield document, command, name, source
+
+
+def options_of(source):
+    import re
+
+    text = (REPO / source).read_text()
+    return set(re.findall(r'add_argument\(\s*"(--?[a-z][a-z-]*)"', text))
 
 
 def test_documented_commands_use_flags_and_files_that_exist():
     import re
 
     commands = list(documented_commands())
-    assert len(commands) >= 15
+    assert len(commands) >= 25
+    worker = options_of(SCRIPTS["frontend.laya_mps"])
     for document, command, name, source in commands:
         assert (REPO / source).exists(), f"{document}: {source}"
-        options = set(re.findall(r'add_argument\(\s*"(--?[a-z][a-z-]*)"', (REPO / source).read_text()))
-        ours = command.split("--spawn")[0] if name.endswith(".py") else command.split(name, 1)[1]
-        if name == "benchmarks/laya_mps/paired.py":
-            ours = re.sub(r'"[^"]*"', "", ours)  # --a/--b carry flags of the worker, checked below
-            for worker_flags in re.findall(r'--[ab] "([^"]*)"', command):
-                assert set(re.findall(r"--[a-z-]+", worker_flags)) <= set(
-                    re.findall(r'add_argument\(\s*"(--[a-z-]+)"', (REPO / SCRIPTS["frontend.laya_mps"]).read_text())
-                ), f"{document}: {command}"
+        ours = command.split(name, 1)[1].split("--spawn")[0]
+        # --a/--b/--flags carry the worker's flags: check those against the worker
+        passed = re.findall(r'--(?:a|b|flags)(?: "([^"]*)"|=(\S+))', ours)
+        for value in (quoted or bare for quoted, bare in passed):
+            assert set(re.findall(r"--[a-z-]+", value)) <= worker, (
+                f"{document}: {command}"
+            )
+        ours = re.sub(r'(--(?:a|b|flags))(?: "[^"]*"|=\S+)', r"\1", ours)
         used = set(re.findall(r"(?<![\w-])(--[a-z][a-z-]*)", ours))
-        assert used <= options, f"{document}: {command}: unknown {sorted(used - options)}"
+        unknown = sorted(used - options_of(source))
+        assert not unknown, f"{document}: {command}: unknown {unknown}"
 
 
 def test_the_header_degrades_to_none_where_macos_tools_are_missing(monkeypatch):
     run = bench_env._run
     macos_only = ("pmset", "sysctl", "system_profiler")
-    monkeypatch.setattr(bench_env, "_run", lambda *cmd: None if cmd[0] in macos_only else run(*cmd))
-    record = bench_env.header("some/repo")  # what a Linux machine records: no failure, the probes are None
-    assert (record["power"], record["chip"], record["gpu_cores"], record["mem_gb"]) == (None, None, None, 0)
+    monkeypatch.setattr(
+        bench_env, "_run", lambda *cmd: None if cmd[0] in macos_only else run(*cmd)
+    )
+    # what a Linux machine records: no failure, the probes are None
+    record = bench_env.header("some/repo")
+    assert (record["power"], record["chip"], record["gpu_cores"], record["mem_gb"]) == (
+        None,
+        None,
+        None,
+        0,
+    )
     assert record["omni_sha"] and record["torch"]
 
 
@@ -108,7 +165,13 @@ def test_parity_lists_benchmark_runs_but_not_runs_that_never_answer():
     records = [
         {"type": "env", "config": "C2", "run": "x"},
         {"type": "phase", "config": "C2", "run": "x"},
-        {"type": "answers", "config": "C2", "run": "x", "workload": "W1", "answers": NOUL},
+        {
+            "type": "answers",
+            "config": "C2",
+            "run": "x",
+            "workload": "W1",
+            "answers": NOUL,
+        },
         # profile_mps.py: an env record and its own measurements, never answers
         {"type": "env", "config": "profile-mps", "run": "x"},
         {"type": "sweep", "config": "profile-mps", "run": "x"},
@@ -118,7 +181,14 @@ def test_parity_lists_benchmark_runs_but_not_runs_that_never_answer():
         # a benchmark run whose answer probes all failed
         {"type": "env", "config": "C4", "run": "x"},
         {"type": "phase", "config": "C4", "run": "x"},
-        {"type": "answers_error", "config": "C4", "run": "x", "workload": "W1", "status": 500, "detail": "x"},
+        {
+            "type": "answers_error",
+            "config": "C4",
+            "run": "x",
+            "workload": "W1",
+            "status": 500,
+            "detail": "x",
+        },
     ]
     out = report.parity(records, "C2")
     assert "profile-mps" not in out
@@ -137,7 +207,13 @@ def summary_of(tmp_path, capsys, a, b):
     records = [{"type": "env", "run": "x", "a": "A", "b": "B", "loadavg_1m": 1.0}]
     records += [{"type": "answers", "side": side, "workload": "W1", "answers": ans, "error": None}
                 for side, ans in (("A", a), ("B", b))]  # fmt: skip
-    records.append({"type": "end", "health": {"A": {"device": "mps"}, "B": {"device": "mps"}}, "footprint_mb": {}})
+    records.append(
+        {
+            "type": "end",
+            "health": {"A": {"device": "mps"}, "B": {"device": "mps"}},
+            "footprint_mb": {},
+        }
+    )
     path = tmp_path / "paired_x.jsonl"
     path.write_text("\n".join(json.dumps(r) for r in records))
     paired.summarize([str(path)])
@@ -151,5 +227,419 @@ def test_paired_summary_reports_a_question_missing_on_either_side(tmp_path, caps
 
 
 def test_paired_summary_reports_answers_of_different_shape(tmp_path, capsys):
-    out = summary_of(tmp_path, capsys, {"q": CHOICE_ANSWER}, {"q": {"type": "noul", "noul": 0.9}})
+    out = summary_of(
+        tmp_path, capsys, {"q": CHOICE_ANSWER}, {"q": {"type": "noul", "noul": 0.9}}
+    )
     assert "errors ['W1/q']" in out
+
+
+# --------------------------------------------------------------------------------------------- lengths.py
+import lengths  # noqa: E402
+
+
+def test_only_lengths_the_worker_has_not_run_are_measured():
+    # laya's W1 question: tokens = words + 56
+    window, overhead, warm = (
+        512,
+        56,
+        {182, 432},
+    )
+    requests = []
+
+    def request(side, words):
+        requests.append((side, words))
+        return 30.0, min(words + overhead, window)
+
+    measured = lengths.measure(["A", "B"], request, 1, 1, 1000, warm, lambda r: None)
+    tokens = [t for _, t in measured]
+    assert len(tokens) == len(set(tokens)) == window - overhead - len(warm)
+    assert not set(tokens) & warm and max(tokens) == window  # stops at the window
+    assert {side for side, _ in requests} == {"A", "B"}
+
+
+def test_lengths_summary_reports_extra_time_and_memory_per_side(tmp_path, capsys):
+    records = [
+        {"type": "env", "run": "x", "a": "plain", "b": "fast", "loadavg_1m": 1.0}
+    ]
+    for side, extra in (("A", 5.0), ("B", 15.0)):
+        records += [
+            {"type": "length", "side": side, "words": w, "tokens": w + 27,
+             "first_ms": 40.0 + extra, "again_ms": 40.0}
+            for w in (37, 41, 45)
+        ]  # fmt: skip
+    records.append(
+        {
+            "type": "end",
+            "footprint_before_mb": {"A": 3400, "B": 2700},
+            "footprint_after_mb": {"A": 3410, "B": 2716},
+            "recompiled_after_ready": {"A": None, "B": False},
+        }
+    )
+    path = tmp_path / "lengths_x.jsonl"
+    path.write_text("\n".join(json.dumps(r) for r in records))
+    lengths.summarize([str(path)])
+    out = capsys.readouterr().out
+    assert "| A | `plain` | 3 | 5.0 (5.0) | 3400 → 3410 | None |" in out
+    assert "| B | `fast` | 3 | 15.0 (15.0) | 2700 → 2716 | False |" in out
+
+
+def test_paired_summary_says_how_requests_were_paced(tmp_path, capsys):
+    both = {"q": CHOICE_ANSWER}
+    assert "back to back" in summary_of(tmp_path, capsys, both, both)
+    path = tmp_path / "paired_x.jsonl"
+    records = [json.loads(line) for line in path.read_text().splitlines()]
+    records[0]["gap_s"] = 2.0
+    path.write_text("\n".join(json.dumps(r) for r in records))
+    paired.summarize([str(path)])
+    assert "2.0 s idle before each request" in capsys.readouterr().out
+
+
+def test_every_option_has_a_command_that_measures_it_alone():
+    index = (BENCH / "README.md").read_text()
+    assert 'paired.py --run p2 --a "" --b=--compile' in index
+    assert 'paired.py --run p3 --a "" --b "--weights fp16"' in index
+
+
+class FakeLateServer:
+    """Stands in for late_load's worker, frontend and HTTP client. The late request answers `status`
+    (or raises `error`), after which the late checkpoint is resident or not."""
+
+    def __init__(self, status, resident, error=None):
+        self.status, self.resident, self.error, self.posts = status, resident, error, []
+
+    def client(self, url, timeout=120):
+        server = self
+
+        class FakeClient:
+            def request(self, method, path, body=None, retry=False):
+                if method == "POST":
+                    server.posts.append((url, timeout))
+                    if server.error and len(server.posts) == 1:
+                        raise server.error
+                    return 20.0, server.status if len(server.posts) == 1 else 200, b"{}"
+                models = {"english": {}}
+                if server.posts and server.resident:
+                    models["multilingual"] = {}
+                return (
+                    1.0,
+                    200,
+                    json.dumps({"preparing": [], "models": models}).encode(),
+                )
+
+        return FakeClient()
+
+
+def late_load_with(monkeypatch, status, *argv, resident=True, error=None):
+    import late_load
+
+    server = FakeLateServer(status, resident, error)
+    monkeypatch.setattr(late_load, "Client", server.client)
+    monkeypatch.setattr(late_load, "spawn", lambda *a, **k: object())
+    monkeypatch.setattr(late_load, "wait_ready", lambda *a, **k: (0.0, {}))
+    monkeypatch.setattr(late_load, "stop", lambda processes: None)
+    args = late_load.parser().parse_args(list(argv))
+    return late_load.attempt(args, through_frontend=False), server
+
+
+def test_the_late_request_waits_as_long_as_asked(monkeypatch):
+    result, server = late_load_with(monkeypatch, 200, "--timeout", "777")
+    assert server.posts == [("http://127.0.0.1:8000", 777)] * 2  # late and next request
+    assert result["first"]["status"] == 200 and result["next"]["status"] == 200
+
+
+def test_a_failed_late_load_is_not_followed_by_a_second_load(monkeypatch):
+    result, server = late_load_with(monkeypatch, 500, resident=False)
+    assert result["first"]["status"] == 500
+    assert result["next"] is None and len(server.posts) == 1
+
+
+def test_a_late_load_cut_off_by_a_timeout_is_still_followed_up(monkeypatch):
+    # the frontend gave up; the worker did not
+    result, server = late_load_with(monkeypatch, 504)
+    assert result["first"]["status"] == 504 and result["next"]["status"] == 200
+    result, _ = late_load_with(monkeypatch, None, error=TimeoutError("timed out"))
+    assert (
+        "TimeoutError" in result["first"]["status"] and result["next"]["status"] == 200
+    )
+
+
+def test_the_length_walk_records_why_it_stopped():
+    def walk(cap, count):
+        records = []
+        lengths.measure(
+            ["A"],
+            lambda s, w: (30.0, min(w + 56, cap)),
+            1,
+            1,
+            count,
+            set(),
+            records.append,
+        )
+        return next(r for r in records if r["type"] == "walk")
+
+    assert walk(512, 1000) == {
+        "type": "walk",
+        "lengths": 456,
+        "stopped": "window",
+        "longest_tokens": 512,
+    }
+    assert walk(512, 10) == {
+        "type": "walk",
+        "lengths": 10,
+        "stopped": "count",
+        "longest_tokens": 66,
+    }
+
+
+def test_every_field_late_load_prints_is_explained_in_its_docstring(monkeypatch):
+    import late_load
+
+    result, _ = late_load_with(monkeypatch, 200)
+    missing = [key for key in result if f"`{key}`" not in late_load.__doc__]
+    assert not missing, missing
+
+
+def test_late_load_refuses_a_late_checkpoint_the_worker_already_serves(monkeypatch):
+    import late_load
+
+    monkeypatch.setattr(
+        late_load, "spawn", lambda *a, **k: pytest.fail("must not start")
+    )
+    for late in ("english", "en", "English"):
+        monkeypatch.setattr(
+            sys, "argv", ["late_load.py", "--model", "english", "--late", late]
+        )
+        with pytest.raises(SystemExit):
+            late_load.main()
+
+
+# --------------------------------------------------------------------------------------------- release.py
+def test_release_walks_new_lengths_releases_and_runs_the_same_lengths_again():
+    import release
+
+    calls, warm, memory = [], {76}, {"mb": 3300.0}
+
+    def run(words):
+        """W1 adds 56 tokens to the state; the window stops at 120. A cold length costs 10 ms and 5 MB."""
+        calls.append(words)
+        tokens = min(words + 56, 120)
+        if tokens in warm:
+            return 20.0, tokens
+        warm.add(tokens)
+        memory["mb"] += 5.0
+        return 30.0, tokens
+
+    def release_caches():
+        calls.append("release")
+        warm.clear()
+        memory["mb"] = 3000.0
+
+    result = release.measure(run, lambda: memory["mb"], release_caches, 10, 10, 100, 0)
+    measured = [10, 20, 30, 40, 50, 60, 70]  # 80 words is past the window
+    twice = [w for w in measured for _ in (0, 1)]
+    assert calls == ["release", *twice, 80, "release", *twice, "release"]
+    assert result["lengths"] == 7 and result["stopped"] == "window"
+    assert result["extra_ms_before_release"] == result["extra_ms_after_release"] == 10.0
+
+
+def test_release_reads_the_footprint_once_the_release_has_landed(monkeypatch):
+    """macOS shows a release in the footprint up to a few seconds later."""
+    import release
+
+    memory, warm, landing = {"mb": 3300.0}, set(), []
+
+    def run(words):
+        if words not in warm:
+            warm.add(words)
+            memory["mb"] += 5.0
+        return 30.0, words
+
+    def release_caches():
+        warm.clear()
+        landing.append(3000.0)
+
+    def wait(seconds):
+        assert seconds == 3
+        if landing:
+            memory["mb"] = landing.pop()
+
+    monkeypatch.setattr(release.time, "sleep", wait)
+    result = release.measure(run, lambda: memory["mb"], release_caches, 10, 10, 2, 3)
+    assert result["settle_s"] == 3
+    assert result["footprint_mb"] == {
+        "before": 3000.0,
+        "after_lengths": 3010.0,
+        "after_release": 3000.0,
+        "after_rerun": 3010.0,
+        "after_second_release": 3000.0,
+    }
+
+
+class FakeRouter:
+    def __init__(self, device="mps"):
+        self.asked = []
+        self.agent = type(
+            "Agent",
+            (),
+            {"device": device, "dtype": "torch.float16", "mps_amp_min_rows": 5},
+        )()
+        self.loaded, self.hooks = ["english"], []
+
+    def load(self, name):
+        return self.agent
+
+    def predict(self, state, questions, model=None):
+        self.asked.append(questions)
+        return {
+            "answers": {},
+            "usage": {"input_tokens": len(state.split()) + 56, "output_tokens": 0},
+            "routing": {"model": model, "repo": "convaiinnovations/laya"},
+        }
+
+
+def test_release_asks_the_w1_question_wherever_it_is_in_the_file(monkeypatch, tmp_path):
+    import release
+
+    workloads = rows(BENCH / "workloads.jsonl")
+    path = tmp_path / "workloads.jsonl"
+    path.write_text("\n".join(json.dumps(w) for w in reversed(workloads)))
+    router = FakeRouter()
+    monkeypatch.setattr(bench_env, "noise_problems", lambda max_load: [])
+    monkeypatch.setattr(release, "prepare", lambda args: router, raising=False)
+    monkeypatch.setattr(release, "measure", lambda run, *a, **k: run(37) and {})
+    monkeypatch.setattr(sys, "argv", ["release.py", "--workloads", str(path)])
+    release.main()
+    assert (
+        router.asked[-1] == next(w for w in workloads if w["id"] == "W1")["questions"]
+    )
+
+
+def must_not_start(*args, **kwargs):
+    pytest.fail("a measured run started on a noisy machine")
+
+
+@pytest.mark.parametrize(
+    "script, argv",
+    [("late_load", []), ("fallback", ["--limit-gb", "3"]), ("release", [])],
+)
+def test_a_measured_run_is_refused_on_a_noisy_machine(monkeypatch, script, argv):
+    import importlib
+
+    module = importlib.import_module(script)
+    monkeypatch.setattr(
+        bench_env, "noise_problems", lambda max_load: ["on Battery Power"]
+    )
+    for name in ("spawn", "prepare"):
+        monkeypatch.setattr(module, name, must_not_start, raising=False)
+    monkeypatch.setattr(subprocess, "run", must_not_start)
+    monkeypatch.setattr(sys, "argv", [f"{script}.py", *argv])
+    with pytest.raises(SystemExit, match="refusing a measured run: on Battery Power"):
+        module.main()
+
+
+def test_fallback_says_why_the_memory_probe_failed(monkeypatch):
+    import fallback
+
+    failed = subprocess.CompletedProcess(
+        [], 1, "", "ModuleNotFoundError: No module named 'torch'\n"
+    )
+    monkeypatch.setattr(bench_env, "noise_problems", lambda max_load: [])
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: failed)
+    monkeypatch.setattr(fallback, "spawn", must_not_start)
+    monkeypatch.setattr(sys, "argv", ["fallback.py", "--limit-gb", "3"])
+    with pytest.raises(SystemExit, match="No module named 'torch'"):
+        fallback.main()
+
+
+def test_the_fresh_start_loop_starts_both_sides_the_recipe_compares():
+    import re
+
+    readme = (BENCH / "README.md").read_text()
+    loop = next(
+        b for b in re.findall(r"```sh\n(.*?)```", readme, flags=re.S) if "for i in" in b
+    )
+    assert "--config C3o" in loop and "--spawn .venv/bin/laya-serve" in loop
+
+
+def test_release_keeps_the_traceback_of_other_failures(monkeypatch):
+    import release
+
+    def prepare(args):
+        raise RuntimeError("inductor could not compile the encoder")
+
+    monkeypatch.setattr(bench_env, "noise_problems", lambda max_load: [])
+    monkeypatch.setattr(release, "prepare", prepare)
+    monkeypatch.setattr(sys, "argv", ["release.py"])
+    with pytest.raises(RuntimeError, match="inductor"):
+        release.main()
+
+
+def test_release_refuses_with_one_line_when_the_model_is_not_on_mps(monkeypatch):
+    import release
+    from frontend import laya_mps as worker
+
+    monkeypatch.setattr(bench_env, "noise_problems", lambda max_load: [])
+    monkeypatch.setattr(worker, "make_router", lambda device, model: FakeRouter("cpu"))
+    monkeypatch.setattr(sys, "argv", ["release.py"])
+    with pytest.raises(SystemExit, match="english is on cpu"):
+        release.main()
+
+
+def test_feasibility_results_say_the_machine_was_noisy(monkeypatch, capsys):
+    import late_load
+
+    server = FakeLateServer(200, resident=True)
+    monkeypatch.setattr(
+        bench_env, "noise_problems", lambda max_load: ["on Battery Power"]
+    )
+    monkeypatch.setattr(late_load, "Client", server.client)
+    monkeypatch.setattr(late_load, "spawn", lambda *a, **k: object())
+    monkeypatch.setattr(late_load, "wait_ready", lambda *a, **k: (0.0, {}))
+    monkeypatch.setattr(late_load, "stop", lambda processes: None)
+    monkeypatch.setattr(sys, "argv", ["late_load.py", "--feasibility"])
+    late_load.main()
+    assert json.loads(capsys.readouterr().out)["noise"] == ["on Battery Power"]
+
+
+def test_fallback_output_says_the_machine_was_noisy(monkeypatch, capsys):
+    import fallback
+
+    class Started(Exception):
+        pass
+
+    def started(*args, **kwargs):
+        raise Started
+
+    probe = subprocess.CompletedProcess([], 0, str(12 * 2**30), "")
+    monkeypatch.setattr(
+        bench_env, "noise_problems", lambda max_load: ["on Battery Power"]
+    )
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: probe)
+    monkeypatch.setattr(fallback, "spawn", started)
+    monkeypatch.setattr(
+        sys, "argv", ["fallback.py", "--limit-gb", "3", "--feasibility"]
+    )
+    with pytest.raises(Started):
+        fallback.main()
+    assert "on Battery Power" in capsys.readouterr().out
+
+
+def test_workloads_with_a_repeated_id_are_refused(tmp_path):
+    path = tmp_path / "workloads.jsonl"
+    path.write_text('{"id": "W1", "kind": "bench"}\n{"id": "W1", "kind": "parity"}\n')
+    with pytest.raises(ValueError, match="W1"):
+        bench_env.read_workloads(path)
+
+
+def test_the_warm_lengths_are_the_requests_the_warmup_sends(monkeypatch):
+    import lengths
+    from models.laya import engine
+
+    def warmup(router, model, shapes=engine.WARMUP_SHAPES, repeats=2):
+        for words, questions in shapes:
+            router.predict(" ".join(["billing"] * words), questions, model=model)
+
+    monkeypatch.setattr(engine, "warmup", warmup)
+    states = []
+    lengths.warmup_lengths(lambda state, questions: states.append(state) or 1)
+    assert states and all(set(state.split()) == {"billing"} for state in states)
diff --git a/tests/laya/test_contract.py b/tests/laya/test_contract.py
index 17d779f..9ef6017 100644
--- a/tests/laya/test_contract.py
+++ b/tests/laya/test_contract.py
@@ -13,7 +13,6 @@
 import os
 import shlex
 import socket
-import statistics
 import subprocess
 import sys
 import time
@@ -21,7 +20,9 @@
 
 import pytest
 
-pytestmark = pytest.mark.skipif(os.environ.get("LAYA_CONTRACT") != "1", reason="set LAYA_CONTRACT=1")
+pytestmark = pytest.mark.skipif(
+    os.environ.get("LAYA_CONTRACT") != "1", reason="set LAYA_CONTRACT=1"
+)
 
 SRC = Path(__file__).resolve().parents[2] / "src"
 DEVICE = os.environ.get("LAYA_CONTRACT_DEVICE", "cpu")
@@ -64,7 +65,13 @@ def call(port, method, path, body=None, token=TOKEN, raw=False):
 
 
 def decide(port, questions, **kwargs):
-    return call(port, "POST", "/v1/systemone", {"model": "english", "state": STATE, "questions": questions}, **kwargs)
+    return call(
+        port,
+        "POST",
+        "/v1/systemone",
+        {"model": "english", "state": STATE, "questions": questions},
+        **kwargs,
+    )
 
 
 @pytest.fixture(scope="module")
@@ -127,14 +134,19 @@ def test_health_reports_the_loaded_model(worker):
     assert health["device_mismatch"] is False
     assert health["checkpoint"] == CHECKPOINT
     assert health["loaded"] == ["english"]
-    assert health["weights_dtype"] == ("torch.float16" if "fp16" in FLAGS else "torch.float32")
+    assert health["weights_dtype"] == (
+        "torch.float16" if "fp16" in FLAGS else "torch.float32"
+    )
     assert len(health["revision"]) == 40
 
 
 def test_the_first_health_answer_comes_after_the_warmup(worker):
     # laya-serve also refuses connections while it loads, then answers /health before any forward pass;
     # the worker's first answer must already report a finished warmup.
-    assert startup["first_health"]["ready"] is True and startup["first_health"]["warmup_ms"] > 0
+    assert (
+        startup["first_health"]["ready"] is True
+        and startup["first_health"]["warmup_ms"] > 0
+    )
 
 
 def test_the_checkpoint_stays_loaded_across_requests(worker):
@@ -142,16 +154,22 @@ def test_the_checkpoint_stays_loaded_across_requests(worker):
     for _ in range(5):
         assert decide(port, {"q": NOUL})[0] == 200
     health = json.loads(call(port, "GET", "/health")[1])
-    assert health["loaded"] == ["english"] and health["warmup_ms"] == startup["first_health"]["warmup_ms"]
-
-
-def test_first_request_after_ready_is_not_a_cold_start(worker):
-    port, (status, _, first_ms) = worker
+    assert (
+        health["loaded"] == ["english"]
+        and health["warmup_ms"] == startup["first_health"]["warmup_ms"]
+    )
+
+
+def test_the_first_request_after_ready_succeeds(worker):
+    # Its latency is measured by the benchmarks, not asserted here: on MPS it depends on
+    # how long the GPU has been idle since the warmup (tens to over a hundred ms on an
+    # M1 Pro), and on an M5 even a worker without warmup answered its first request in
+    # 132-143 ms, so no bound separates warm from cold on every Mac. That the warmup ran
+    # before ready is checked above.
+    _, (status, body, _) = worker
     assert status == 200
-    warm = statistics.median(decide(port, {"q": CHOICE})[2] for _ in range(20))
-    # Without the warmup the first request costs several hundred ms more than a warm one. A few tens of ms
-    # remain on MPS: the GPU has been idle since the warmup, and any request after a pause pays that.
-    assert first_ms <= warm + 100, f"first {first_ms:.0f} ms, warm p50 {warm:.0f} ms"
+    answer = json.loads(body)["answers"]["q"]
+    assert answer["type"] == "choice" and answer["choice"] in CHOICE["criteria"]
 
 
 @pytest.mark.parametrize(
@@ -160,7 +178,10 @@ def test_first_request_after_ready_is_not_a_cold_start(worker):
         ({"q": CHOICE}, {"q": "choice"}),
         ({"q": SCORE}, {"q": "score"}),
         ({"q": NOUL}, {"q": "noul"}),
-        ({"a": CHOICE, "b": SCORE, "c": NOUL}, {"a": "choice", "b": "score", "c": "noul"}),
+        (
+            {"a": CHOICE, "b": SCORE, "c": NOUL},
+            {"a": "choice", "b": "score", "c": "noul"},
+        ),
     ],
     ids=["choice", "score", "noul", "combined"],
 )
@@ -187,7 +208,13 @@ def test_decisions(worker, questions, kinds):
 
 @pytest.mark.parametrize(
     "questions",
-    [{"q": CHOICE}, {"q": SCORE}, {"q": NOUL}, {"a": CHOICE, "b": SCORE, "c": NOUL}, SIX],
+    [
+        {"q": CHOICE},
+        {"q": SCORE},
+        {"q": NOUL},
+        {"a": CHOICE, "b": SCORE, "c": NOUL},
+        SIX,
+    ],
     ids=["choice", "score", "noul", "combined", "six-questions"],
 )
 def test_answers_match_laya_itself(worker, reference, questions):
@@ -198,7 +225,10 @@ def test_answers_match_laya_itself(worker, reference, questions):
     expected = reference.system_one(STATE, questions)
     assert set(expected) <= set(served)  # the worker adds `routing`, it drops nothing
     assert served["usage"] == expected["usage"]
-    reduced = "fp16" in FLAGS or (DEVICE == "mps" and len(questions) >= startup["first_health"]["mps_amp_min_rows"])
+    reduced = "fp16" in FLAGS or (
+        DEVICE == "mps"
+        and len(questions) >= startup["first_health"]["mps_amp_min_rows"]
+    )
     tolerance = 1e-2 if reduced else 1e-3
     for qid, want in expected["answers"].items():
         got = served["answers"][qid]
@@ -210,12 +240,19 @@ def test_answers_match_laya_itself(worker, reference, questions):
         for option, p in want["probabilities"].items():
             assert got["probabilities"][option] == pytest.approx(p, abs=tolerance)
         if want["type"] == "choice":
-            assert got["choice"] == want["choice"] == max(got["probabilities"], key=got["probabilities"].get)
+            assert (
+                got["choice"]
+                == want["choice"]
+                == max(got["probabilities"], key=got["probabilities"].get)
+            )
 
 
 def test_same_request_same_answer(worker):
     port, _ = worker
-    first, second = (json.loads(decide(port, {"a": CHOICE, "b": NOUL})[1])["answers"] for _ in range(2))
+    first, second = (
+        json.loads(decide(port, {"a": CHOICE, "b": NOUL})[1])["answers"]
+        for _ in range(2)
+    )
     assert first == second
 
 
@@ -225,16 +262,37 @@ def test_same_request_same_answer(worker):
         (b"{not json", True, TOKEN, 400),
         ({"model": "english", "state": STATE}, False, TOKEN, 400),
         (
-            {"model": "english", "state": STATE, "questions": {"q": {"type": "bogus", "instructions": "?"}}},
+            {
+                "model": "english",
+                "state": STATE,
+                "questions": {"q": {"type": "bogus", "instructions": "?"}},
+            },
             False,
             TOKEN,
             422,
         ),
         (b"x" * (2 * 1024 * 1024 + 1), True, TOKEN, 413),
-        ({"model": "english", "state": STATE, "questions": {"q": NOUL}}, False, "wrong", 401),
-        ({"model": "english", "state": STATE, "questions": {"q": NOUL}}, False, None, 401),
+        (
+            {"model": "english", "state": STATE, "questions": {"q": NOUL}},
+            False,
+            "wrong",
+            401,
+        ),
+        (
+            {"model": "english", "state": STATE, "questions": {"q": NOUL}},
+            False,
+            None,
+            401,
+        ),
+    ],
+    ids=[
+        "malformed-json",
+        "no-questions",
+        "bad-question",
+        "too-large",
+        "wrong-token",
+        "no-token",
     ],
-    ids=["malformed-json", "no-questions", "bad-question", "too-large", "wrong-token", "no-token"],
 )
 def test_errors(worker, body, raw, token, expected):
     port, _ = worker
diff --git a/tests/laya/test_worker.py b/tests/laya/test_worker.py
index b8f81f7..1a71507 100644
--- a/tests/laya/test_worker.py
+++ b/tests/laya/test_worker.py
@@ -1,6 +1,6 @@
 """Unit tests for the Laya worker. A fake Router stands in for laya's; no model is loaded.
 
-python -m pytest src/models/laya/tests
+PYTHONPATH=src python -m pytest tests/laya
 """
 
 import sys
@@ -83,7 +83,9 @@ def test_warmup_covers_short_long_and_fp16_multi_question_shapes():
     rows = {len(questions) for _, questions, _ in router.calls}
     assert min(words) <= 20 and max(words) >= 400
     assert max(rows) >= router.agent.mps_amp_min_rows
-    assert {q["type"] for _, questions, _ in router.calls for q in questions.values()} == {"choice", "score", "noul"}
+    assert {
+        q["type"] for _, questions, _ in router.calls for q in questions.values()
+    } == {"choice", "score", "noul"}
     assert len(router.calls) == len(engine.WARMUP_SHAPES) * engine.WARMUP_REPEATS
     assert all(model == "english" for _, _, model in router.calls)
 
@@ -101,7 +103,9 @@ def test_warmup_failure_raises_and_no_app_is_built():
 
 def test_health_reports_the_agent_device_not_the_requested_one():
     router = FakeRouter(FakeAgent(device="cpu", dtype="torch.float32"))
-    health = TestClient(worker.build_app(router, "english", "mps")).get("/health").json()
+    health = (
+        TestClient(worker.build_app(router, "english", "mps")).get("/health").json()
+    )
     assert health["device"] == "cpu"
     assert health["requested_device"] == "mps"
     assert health["device_mismatch"] is True
@@ -109,7 +113,11 @@ def test_health_reports_the_agent_device_not_the_requested_one():
 
 
 def test_health_on_the_requested_device():
-    health = TestClient(worker.build_app(FakeRouter(), "english", "mps")).get("/health").json()
+    health = (
+        TestClient(worker.build_app(FakeRouter(), "english", "mps"))
+        .get("/health")
+        .json()
+    )
     assert health["device"] == "mps"
     assert health["device_mismatch"] is False
     assert health["autocast_dtype"] == "torch.float16"
@@ -119,7 +127,12 @@ def test_health_on_the_requested_device():
 
 def test_device_index_is_not_a_mismatch():
     router = FakeRouter(FakeAgent(device="cuda:0"))
-    assert TestClient(worker.build_app(router, "english", "cuda")).get("/health").json()["device_mismatch"] is False
+    assert (
+        TestClient(worker.build_app(router, "english", "cuda"))
+        .get("/health")
+        .json()["device_mismatch"]
+        is False
+    )
 
 
 def test_auto_device_is_never_a_mismatch():
@@ -137,7 +150,9 @@ def test_require_device_refuses_to_serve_on_another_device():
 
 def test_only_one_health_route_remains():
     app = worker.build_app(FakeRouter(), "english", "mps")
-    assert [r.path for r in app.router.routes if getattr(r, "path", None) == "/health"] == ["/health"]
+    assert [
+        r.path for r in app.router.routes if getattr(r, "path", None) == "/health"
+    ] == ["/health"]
 
 
 def test_decisions_still_go_through_laya_serve():
@@ -146,7 +161,11 @@ def test_decisions_still_go_through_laya_serve():
     before = len(router.calls)
     response = client.post(
         "/v1/systemone",
-        json={"model": "english", "state": "refund me", "questions": {"r": {"type": "noul", "instructions": "?"}}},
+        json={
+            "model": "english",
+            "state": "refund me",
+            "questions": {"r": {"type": "noul", "instructions": "?"}},
+        },
     )
     assert response.status_code == 200
     assert response.json()["answers"]["r"]["noul"] == 0.9
@@ -154,32 +173,56 @@ def test_decisions_still_go_through_laya_serve():
 
 
 def test_main_exits_non_zero_when_warmup_fails(monkeypatch, caplog):
-    monkeypatch.setattr(worker, "make_router", lambda device, model: FakeRouter(fail_on_call=1))
+    monkeypatch.setattr(
+        worker, "make_router", lambda device, model: FakeRouter(fail_on_call=1)
+    )
     monkeypatch.setattr(sys, "argv", ["laya_mps", "--device", "mps"])
     monkeypatch.setattr("uvicorn.run", lambda *a, **k: pytest.fail("must not bind"))
-    with caplog.at_level("ERROR", logger="laya-worker"), pytest.raises(SystemExit, match="not starting"):
+    with (
+        caplog.at_level("ERROR", logger="laya-worker"),
+        pytest.raises(SystemExit, match="not starting"),
+    ):
         worker.main()
-    assert "startup failed" in caplog.text and "Traceback" in caplog.text and "out of memory" in caplog.text
+    assert (
+        "startup failed" in caplog.text
+        and "Traceback" in caplog.text
+        and "out of memory" in caplog.text
+    )
 
 
 def test_compile_wraps_the_model_before_warmup(monkeypatch):
     router = FakeRouter()
     order = []
-    monkeypatch.setattr(optimize, "compile_agent", lambda agent: order.append((agent, len(router.calls))))
+    monkeypatch.setattr(
+        optimize,
+        "compile_agent",
+        lambda agent: order.append((agent, len(router.calls))),
+    )
     worker.build_app(router, "english", "mps", compile=True, graph_counter=lambda: 3)
     assert order == [(router.agent, 0)]
 
 
 def test_health_reports_compile_off_by_default():
-    health = TestClient(worker.build_app(FakeRouter(), "english", "mps")).get("/health").json()
+    health = (
+        TestClient(worker.build_app(FakeRouter(), "english", "mps"))
+        .get("/health")
+        .json()
+    )
     assert health["compile"] == {"enabled": False}
 
 
 def test_health_flags_graphs_compiled_after_ready(monkeypatch):
     monkeypatch.setattr(optimize, "compile_agent", lambda agent: None)
-    graphs = iter([4, 4, 5])  # at readiness, first /health, second /health after a new shape compiled
+    # at readiness, first /health, second /health after a new shape compiled
+    graphs = iter([4, 4, 5])
     client = TestClient(
-        worker.build_app(FakeRouter(), "english", "mps", compile=True, graph_counter=lambda: next(graphs))
+        worker.build_app(
+            FakeRouter(),
+            "english",
+            "mps",
+            compile=True,
+            graph_counter=lambda: next(graphs),
+        )
     )
     first = client.get("/health").json()["compile"]
     assert first == {
@@ -227,7 +270,11 @@ def forward(self, *args):
 
     def fake_compile(module, dynamic):
         assert dynamic is True
-        return Stub("compiled encoder" if isinstance(module, Encoder) else "whole model compiled")
+        return Stub(
+            "compiled encoder"
+            if isinstance(module, Encoder)
+            else "whole model compiled"
+        )
 
     monkeypatch.setattr(torch, "compile", fake_compile)
     agent = FakeAgent()
@@ -237,14 +284,21 @@ def fake_compile(module, dynamic):
     assert agent.model(on_gpu(1)) == "whole model compiled"
     assert agent.model(on_gpu(3)) == ("head", "compiled encoder")
     assert agent.model(torch.zeros(1, 7)) == ("head", "eager encoder")
-    assert model.encoder(torch.zeros(1, 7)) == "eager encoder"  # the original model is left as it was
-    assert len(list(agent.model.parameters())) == len(list(model.parameters()))  # one set of weights
+    # the original model is left as it was
+    assert model.encoder(torch.zeros(1, 7)) == "eager encoder"
+    # one set of weights
+    assert len(list(agent.model.parameters())) == len(list(model.parameters()))
 
 
 def test_every_loaded_model_is_warmed_and_described():
-    agents = {"english": FakeAgent(), "multilingual": FakeAgent(device="cpu", dtype="torch.float32")}
+    agents = {
+        "english": FakeAgent(),
+        "multilingual": FakeAgent(device="cpu", dtype="torch.float32"),
+    }
     router = FakeRouter(agents=agents)
-    health = TestClient(worker.build_app(router, "english", "mps")).get("/health").json()
+    health = (
+        TestClient(worker.build_app(router, "english", "mps")).get("/health").json()
+    )
     per_model = len(engine.WARMUP_SHAPES) * engine.WARMUP_REPEATS
     assert [m for _, _, m in router.calls].count("multilingual") == per_model
     assert [m for _, _, m in router.calls].count("english") == per_model
@@ -256,7 +310,9 @@ def test_every_loaded_model_is_warmed_and_described():
 
 def test_a_model_that_is_not_preloaded_is_not_loaded_for_warmup():
     router = FakeRouter(agents={"multilingual": FakeAgent()})
-    health = TestClient(worker.build_app(router, "english", "mps")).get("/health").json()
+    health = (
+        TestClient(worker.build_app(router, "english", "mps")).get("/health").json()
+    )
     assert "english" not in router.loads
     assert {m for _, _, m in router.calls} == {"multilingual"}
     assert set(health["models"]) == {"multilingual"}
@@ -270,9 +326,15 @@ def test_nothing_preloaded_warms_the_worker_model():
 
 def test_revision_comes_from_the_loaded_snapshot_not_a_guess():
     revisions = {"convaiinnovations/laya": "55cf4c4"}
-    health = TestClient(worker.build_app(FakeRouter(), "english", "mps", revisions=revisions)).get("/health")
+    health = TestClient(
+        worker.build_app(FakeRouter(), "english", "mps", revisions=revisions)
+    ).get("/health")
     assert health.json()["revision"] == "55cf4c4"
-    unknown = TestClient(worker.build_app(FakeRouter(), "english", "mps")).get("/health").json()
+    unknown = (
+        TestClient(worker.build_app(FakeRouter(), "english", "mps"))
+        .get("/health")
+        .json()
+    )
     assert unknown["revision"] is None
 
 
@@ -283,19 +345,29 @@ def test_record_snapshot_revisions_reads_the_downloaded_path(monkeypatch):
         "convaiinnovations/laya": "/cache/models--convaiinnovations--laya/snapshots/55cf4c4abc/multilingual",
         "/local/checkpoint": "/local/checkpoint",
     }
-    monkeypatch.setattr(huggingface_hub, "snapshot_download", lambda repo_id, **kwargs: paths[repo_id])
+    monkeypatch.setattr(
+        huggingface_hub, "snapshot_download", lambda repo_id, **kwargs: paths[repo_id]
+    )
     revisions = engine.record_snapshot_revisions()
     assert (
-        huggingface_hub.snapshot_download("convaiinnovations/laya", allow_patterns=["*"])
+        huggingface_hub.snapshot_download(
+            "convaiinnovations/laya", allow_patterns=["*"]
+        )
         == paths["convaiinnovations/laya"]
     )
     huggingface_hub.snapshot_download("/local/checkpoint")
     assert revisions == {"convaiinnovations/laya": "55cf4c4abc"}
     huggingface_hub.snapshot_download(
-        "convaiinnovations/laya", allow_patterns=["multilingual/model.safetensors", "multilingual/tokenizer/*"]
+        "convaiinnovations/laya",
+        allow_patterns=["multilingual/model.safetensors", "multilingual/tokenizer/*"],
+    )
+    huggingface_hub.snapshot_download(
+        "convaiinnovations/laya", allow_patterns=["model.safetensors", "tokenizer/*"]
     )
-    huggingface_hub.snapshot_download("convaiinnovations/laya", allow_patterns=["model.safetensors", "tokenizer/*"])
-    assert set(revisions) == {"convaiinnovations/laya", "convaiinnovations/laya/multilingual"}
+    assert set(revisions) == {
+        "convaiinnovations/laya",
+        "convaiinnovations/laya/multilingual",
+    }
 
 
 def test_fp16_weights_keep_act_head_in_fp32():
@@ -318,24 +390,44 @@ def test_fp16_weights_are_applied_to_every_loaded_model_before_warmup(monkeypatc
     order = []
     agents = {"english": FakeAgent(), "multilingual": FakeAgent()}
     router = FakeRouter(agents=agents)
-    monkeypatch.setattr(optimize, "use_fp16_weights", lambda agent: order.append((agent, len(router.calls))))
+    monkeypatch.setattr(
+        optimize,
+        "use_fp16_weights",
+        lambda agent: order.append((agent, len(router.calls))),
+    )
     worker.build_app(router, "english", "mps", fp16=True)
     assert order == [(agents["english"], 0), (agents["multilingual"], 0)]
 
 
 def test_options_are_not_applied_to_a_model_on_the_cpu(monkeypatch, caplog):
     applied = []
-    monkeypatch.setattr(optimize, "use_fp16_weights", lambda agent: applied.append("fp16"))
-    monkeypatch.setattr(optimize, "compile_agent", lambda agent: applied.append("compile"))
+    monkeypatch.setattr(
+        optimize, "use_fp16_weights", lambda agent: applied.append("fp16")
+    )
+    monkeypatch.setattr(
+        optimize, "compile_agent", lambda agent: applied.append("compile")
+    )
     with caplog.at_level("WARNING", logger="laya-worker"):
         worker.build_app(
-            FakeRouter(FakeAgent(device="cpu")), "english", "cpu", fp16=True, compile=True, graph_counter=lambda: 0
+            FakeRouter(FakeAgent(device="cpu")),
+            "english",
+            "cpu",
+            fp16=True,
+            compile=True,
+            graph_counter=lambda: 0,
         )
     assert applied == []
     assert "apply on the GPU only" in caplog.text
     caplog.clear()
     with caplog.at_level("WARNING", logger="laya-worker"):
-        worker.build_app(FakeRouter(), "english", "mps", fp16=True, compile=True, graph_counter=lambda: 0)
+        worker.build_app(
+            FakeRouter(),
+            "english",
+            "mps",
+            fp16=True,
+            compile=True,
+            graph_counter=lambda: 0,
+        )
     assert applied == ["fp16", "compile"]
     assert "GPU only" not in caplog.text
 
@@ -352,7 +444,9 @@ def __init__(self):
         def forward(self, input_ids):
             return ("eager", self.encoder.weight.dtype)
 
-    monkeypatch.setattr(torch, "compile", lambda module, dynamic: lambda *a, **k: "compiled")
+    monkeypatch.setattr(
+        torch, "compile", lambda module, dynamic: lambda *a, **k: "compiled"
+    )
     agent = FakeAgent()
     agent.model = Model()
     optimize.use_fp16_weights(agent)
@@ -366,7 +460,9 @@ def forward(self, input_ids):
 
 def test_health_follows_a_fallback_to_cpu_after_startup():
     agent = FakeAgent(device="mps")
-    client = TestClient(worker.build_app(FakeRouter(agent), "english", "mps", require_device=True))
+    client = TestClient(
+        worker.build_app(FakeRouter(agent), "english", "mps", require_device=True)
+    )
     assert client.get("/health").json()["device_mismatch"] is False
     agent.device = "cpu"
     agent.dtype = "torch.float32"
@@ -381,13 +477,20 @@ def test_health_compile_active_follows_a_fallback_to_cpu(monkeypatch):
     import torch
 
     compiles = []
-    monkeypatch.setattr(torch, "compile", lambda module, dynamic: compiles.append(module) or module)
+    monkeypatch.setattr(
+        torch, "compile", lambda module, dynamic: compiles.append(module) or module
+    )
     agent = FakeAgent()
     agent.model = torch.nn.Sequential()
     agent.model.encoder = torch.nn.Identity()
-    client = TestClient(worker.build_app(FakeRouter(agent), "english", "mps", compile=True, graph_counter=lambda: 2))
+    client = TestClient(
+        worker.build_app(
+            FakeRouter(agent), "english", "mps", compile=True, graph_counter=lambda: 2
+        )
+    )
     assert client.get("/health").json()["compile"]["active"] is True
-    optimize.compile_agent(agent)  # a second name for the same agent must not compile again
+    # a second name for the same agent must not compile again
+    optimize.compile_agent(agent)
     assert len(compiles) == 2
     agent.device = "cpu"
     assert client.get("/health").json()["compile"]["active"] is False
@@ -410,21 +513,30 @@ def test_log_level_applies_to_the_workers_own_log(monkeypatch):
     monkeypatch.setattr(worker, "make_router", lambda device, model: FakeRouter())
     monkeypatch.setattr(worker.logging, "basicConfig", lambda **kw: seen.update(kw))
     monkeypatch.setattr("uvicorn.run", lambda app, **kw: seen.update(uvicorn=kw))
-    monkeypatch.setattr(sys, "argv", ["laya_mps", "--device", "mps", "--log-level", "warning"])
+    monkeypatch.setattr(
+        sys, "argv", ["laya_mps", "--device", "mps", "--log-level", "warning"]
+    )
     worker.main()
     assert (seen["level"], seen["uvicorn"]["log_level"]) == ("WARNING", "warning")
-    assert (seen["uvicorn"]["host"], seen["uvicorn"]["port"]) == ("127.0.0.1", 8000)  # local only by default
+    # local only by default
+    assert (seen["uvicorn"]["host"], seen["uvicorn"]["port"]) == (
+        "127.0.0.1",
+        8000,
+    )
 
 
 def test_a_checkpoint_loaded_while_serving_is_prepared_and_described(monkeypatch):
     applied = []
-    monkeypatch.setattr(optimize, "use_fp16_weights", lambda agent: applied.append(agent))
+    monkeypatch.setattr(
+        optimize, "use_fp16_weights", lambda agent: applied.append(agent)
+    )
     router = FakeRouter()
     client = TestClient(worker.build_app(router, "english", "mps", fp16=True))
     before = len(router.calls)
     late = FakeAgent(device="cpu", dtype="torch.float32")
     router.load_while_serving("multilingual", late)
-    assert applied == [router.agent]  # the late one is on the CPU, where the options do not apply
+    # the late one is on the CPU, where the options do not apply
+    assert applied == [router.agent]
     assert [m for _, _, m in router.calls[before:]] == ["multilingual"] * (
         len(engine.WARMUP_SHAPES) * engine.WARMUP_REPEATS
     )
@@ -456,16 +568,30 @@ def test_compile_baseline_moves_when_a_late_checkpoint_compiles(monkeypatch):
     monkeypatch.setattr(optimize, "compile_agent", lambda agent: None)
     graphs = iter([3, 7, 7])  # startup, after the late checkpoint compiled, /health
     router = FakeRouter()
-    client = TestClient(worker.build_app(router, "english", "mps", compile=True, graph_counter=lambda: next(graphs)))
+    client = TestClient(
+        worker.build_app(
+            router, "english", "mps", compile=True, graph_counter=lambda: next(graphs)
+        )
+    )
     router.load_while_serving("multilingual", FakeAgent())
     compiled = client.get("/health").json()["compile"]
-    assert (compiled["graphs_at_ready"], compiled["recompiled_after_ready"]) == (7, False)
+    assert (compiled["graphs_at_ready"], compiled["recompiled_after_ready"]) == (
+        7,
+        False,
+    )
 
 
 def test_startup_error_names_every_checkpoint_off_the_requested_device():
-    agents = {"english": FakeAgent(device="cpu"), "multilingual": FakeAgent(device="cpu")}
-    with pytest.raises(RuntimeError, match="asked for mps, english is on cpu, multilingual is on cpu"):
-        worker.build_app(FakeRouter(agents=agents), "english", "mps", require_device=True)
+    agents = {
+        "english": FakeAgent(device="cpu"),
+        "multilingual": FakeAgent(device="cpu"),
+    }
+    with pytest.raises(
+        RuntimeError, match="asked for mps, english is on cpu, multilingual is on cpu"
+    ):
+        worker.build_app(
+            FakeRouter(agents=agents), "english", "mps", require_device=True
+        )
 
 
 def test_health_names_a_checkpoint_while_it_is_being_prepared():
@@ -495,7 +621,11 @@ def __init__(self, repo, device=None, token=None, subfolder=None):
         self.mps_amp_min_rows = 5
 
     def system_one(self, state, questions, lang=None, **_):
-        return {"model": "stub", "answers": {qid: ANSWER for qid in questions}, "usage": {}}
+        return {
+            "model": "stub",
+            "answers": {qid: ANSWER for qid in questions},
+            "usage": {},
+        }
 
 
 def test_a_failed_late_load_gives_back_the_checkpoint_laya_evicted_for_it(monkeypatch):
@@ -508,7 +638,11 @@ def test_a_failed_late_load_gives_back_the_checkpoint_laya_evicted_for_it(monkey
     router.preload(["english", "multilingual"])  # laya keeps two checkpoints by default
     client = TestClient(worker.build_app(router, "english", "mps", require_device=True))
     with pytest.raises(RuntimeError, match="typed-decisions is on cpu"):
-        router.predict("refund me", {"r": {"type": "noul", "instructions": "?"}}, model="typed-decisions")
+        router.predict(
+            "refund me",
+            {"r": {"type": "noul", "instructions": "?"}},
+            model="typed-decisions",
+        )
     assert sorted(router.loaded) == ["english", "multilingual"]
     health = client.get("/health").json()
     assert set(health["models"]) == {"english", "multilingual"}
@@ -522,7 +656,9 @@ def test_building_a_second_app_on_a_router_replaces_the_first_apps_hooks():
     assert len(router.hooks) == 1
     before = len(router.calls)
     router.load_while_serving("multilingual", FakeAgent())
-    assert len(router.calls) - before == len(engine.WARMUP_SHAPES) * engine.WARMUP_REPEATS
+    assert (
+        len(router.calls) - before == len(engine.WARMUP_SHAPES) * engine.WARMUP_REPEATS
+    )
 
 
 def test_main_warns_about_laya_serve_variables_it_does_not_read(monkeypatch, caplog):
@@ -538,7 +674,9 @@ def test_main_warns_about_laya_serve_variables_it_does_not_read(monkeypatch, cap
     assert "LAYA_API_KEY" not in caplog.text
 
 
-def test_graphs_compiled_by_a_late_checkpoint_that_fails_are_not_reported_as_recompiles(monkeypatch):
+def test_graphs_compiled_by_a_late_checkpoint_that_fails_are_not_reported_as_recompiles(
+    monkeypatch,
+):
     monkeypatch.setattr(optimize, "compile_agent", lambda agent: None)
     router = FakeRouter()
     graphs = {"n": 0}
@@ -549,7 +687,11 @@ def predict_and_compile(state, questions, model=None):
         return predict(state, questions, model=model)
 
     router.predict = predict_and_compile
-    client = TestClient(worker.build_app(router, "english", "mps", compile=True, graph_counter=lambda: graphs["n"]))
+    client = TestClient(
+        worker.build_app(
+            router, "english", "mps", compile=True, graph_counter=lambda: graphs["n"]
+        )
+    )
     router.fail_on_call = len(router.calls) + 3
     with pytest.raises(RuntimeError, match="out of memory"):
         router.load_while_serving("multilingual", FakeAgent())
@@ -572,7 +714,9 @@ def __init__(self, repo, device=None, token=None, subfolder=None):
 
         prefix = f"{subfolder}/" if subfolder else ""
         path = huggingface_hub.snapshot_download(
-            repo, token=token, allow_patterns=[prefix + "model.safetensors", prefix + "tokenizer/*"]
+            repo,
+            token=token,
+            allow_patterns=[prefix + "model.safetensors", prefix + "tokenizer/*"],
         )
         self.loaded_commit = Path(path).name
         self.subfolder = subfolder
@@ -583,7 +727,11 @@ def __init__(self, repo, device=None, token=None, subfolder=None):
     def system_one(self, state, questions, lang=None, **_):
         if self.subfolder in Repository.broken:
             raise RuntimeError("MPS backend out of memory")
-        return {"model": "stub", "answers": {qid: ANSWER for qid in questions}, "usage": {}}
+        return {
+            "model": "stub",
+            "answers": {qid: ANSWER for qid in questions},
+            "usage": {},
+        }
 
 
 @pytest.fixture
@@ -597,7 +745,9 @@ def laya_router(monkeypatch):
     monkeypatch.setattr(Repository, "device", {})
     monkeypatch.setattr(Repository, "broken", set())
     monkeypatch.setattr(
-        huggingface_hub, "snapshot_download", lambda repo, **kw: f"/hf/snapshots/commit-{Repository.commit}"
+        huggingface_hub,
+        "snapshot_download",
+        lambda repo, **kw: f"/hf/snapshots/commit-{Repository.commit}",
     )
     monkeypatch.setattr(laya.agent, "Agent", DownloadingAgent)
     return Router(device="mps"), engine.record_snapshot_revisions()
@@ -611,7 +761,9 @@ def assert_health_matches(client, router):
     for name, agent in agents.items():
         assert health["models"][name]["device"] == str(agent.device)
         assert health["models"][name]["revision"] == agent.loaded_commit
-    assert health["device_mismatch"] == any(str(agent.device) != "mps" for agent in agents.values())
+    assert health["device_mismatch"] == any(
+        str(agent.device) != "mps" for agent in agents.values()
+    )
 
 
 def test_checkpoints_of_one_repository_keep_the_revision_of_their_own_load(laya_router):
@@ -622,22 +774,38 @@ def test_checkpoints_of_one_repository_keep_the_revision_of_their_own_load(laya_
     client = TestClient(worker.build_app(router, "english", "mps", revisions=revisions))
     assert_health_matches(client, router)
     Repository.commit = 2
-    router.predict("refund me", {"r": {"type": "noul", "instructions": "?"}}, model="typed-decisions")
+    router.predict(
+        "refund me",
+        {"r": {"type": "noul", "instructions": "?"}},
+        model="typed-decisions",
+    )
     assert_health_matches(client, router)
 
 
 @pytest.mark.parametrize("require_device", [False, True])
 @pytest.mark.parametrize("seed", range(8))
-def test_health_matches_the_router_after_any_sequence_of_loads(laya_router, seed, require_device):
+def test_health_matches_the_router_after_any_sequence_of_loads(
+    laya_router, seed, require_device
+):
     import random
 
     router, revisions = laya_router
     names = ["english", "multilingual", "typed-decisions"]
-    subfolder = {"english": None, "multilingual": "multilingual", "typed-decisions": "typed-decisions"}
+    subfolder = {
+        "english": None,
+        "multilingual": "multilingual",
+        "typed-decisions": "typed-decisions",
+    }
     rng = random.Random(seed)
     router.preload(rng.sample(names, rng.choice([1, 2])))
     client = TestClient(
-        worker.build_app(router, router.loaded[0], "mps", require_device=require_device, revisions=revisions)
+        worker.build_app(
+            router,
+            router.loaded[0],
+            "mps",
+            require_device=require_device,
+            revisions=revisions,
+        )
     )
     assert_health_matches(client, router)
     for _ in range(12):
@@ -645,7 +813,11 @@ def test_health_matches_the_router_after_any_sequence_of_loads(laya_router, seed
         Repository.device = {subfolder[n]: "cpu" for n in names if rng.random() < 0.25}
         Repository.broken = {subfolder[n] for n in names if rng.random() < 0.15}
         try:
-            router.predict("refund me", {"r": {"type": "noul", "instructions": "?"}}, model=rng.choice(names))
+            router.predict(
+                "refund me",
+                {"r": {"type": "noul", "instructions": "?"}},
+                model=rng.choice(names),
+            )
         except RuntimeError:
             pass  # a failed late load or forward: the request fails, /health must still match the router
         Repository.broken = set()
@@ -660,12 +832,24 @@ def test_health_answers_with_no_resident_checkpoint(laya_router):
     assert client.get("/health").json()["models"] == {}
 
 
-def test_a_checkpoint_loaded_while_serving_gets_the_gpu_options_before_its_warmup(monkeypatch):
+def test_a_checkpoint_loaded_while_serving_gets_the_gpu_options_before_its_warmup(
+    monkeypatch,
+):
     applied = []
     router = FakeRouter()
-    monkeypatch.setattr(optimize, "use_fp16_weights", lambda agent: applied.append(("fp16", len(router.calls))))
-    monkeypatch.setattr(optimize, "compile_agent", lambda agent: applied.append(("compile", len(router.calls))))
-    worker.build_app(router, "english", "mps", fp16=True, compile=True, graph_counter=lambda: 0)
+    monkeypatch.setattr(
+        optimize,
+        "use_fp16_weights",
+        lambda agent: applied.append(("fp16", len(router.calls))),
+    )
+    monkeypatch.setattr(
+        optimize,
+        "compile_agent",
+        lambda agent: applied.append(("compile", len(router.calls))),
+    )
+    worker.build_app(
+        router, "english", "mps", fp16=True, compile=True, graph_counter=lambda: 0
+    )
     warmed_at_startup = len(router.calls)
     router.load_while_serving("multilingual", FakeAgent())
     assert applied[2:] == [("fp16", warmed_at_startup), ("compile", warmed_at_startup)]
@@ -689,39 +873,65 @@ def test_failed_late_loads_are_logged_with_their_cause(laya_router, caplog):
     router, revisions = laya_router
     router.preload(["english", "multilingual"])
     worker.build_app(router, "english", "mps", require_device=True, revisions=revisions)
-    Repository.device = {"typed-decisions": "cpu", None: "cpu"}  # english cannot come back either
+    # english cannot come back either
+    Repository.device = {
+        "typed-decisions": "cpu",
+        None: "cpu",
+    }
     with caplog.at_level("ERROR", logger="laya-worker"), pytest.raises(RuntimeError):
-        router.predict("refund me", {"r": {"type": "noul", "instructions": "?"}}, model="typed-decisions")
+        router.predict(
+            "refund me",
+            {"r": {"type": "noul", "instructions": "?"}},
+            model="typed-decisions",
+        )
     assert "typed-decisions could not be prepared and is unloaded" in caplog.text
-    assert "english was evicted for typed-decisions and could not be loaded again" in caplog.text
-    assert "asked for mps, typed-decisions is on cpu" in caplog.text  # the traceback of the cause
+    assert (
+        "english was evicted for typed-decisions and could not be loaded again"
+        in caplog.text
+    )
+    # the traceback of the cause
+    assert "asked for mps, typed-decisions is on cpu" in caplog.text
     assert router.loaded == ["multilingual"]
 
 
-def test_a_failed_late_load_reloads_only_what_was_evicted_for_it(laya_router, monkeypatch):
+def test_a_failed_late_load_reloads_only_what_was_evicted_for_it(
+    laya_router, monkeypatch
+):
     router, revisions = laya_router
     router.max_loaded = 1
     router.load("english")
     worker.build_app(router, "english", "mps", require_device=True, revisions=revisions)
-    router.predict("refund me", {"r": {"type": "noul", "instructions": "?"}}, model="multilingual")  # evicts english
+    # evicts english
+    router.predict(
+        "refund me", {"r": {"type": "noul", "instructions": "?"}}, model="multilingual"
+    )
     built = []
     original = DownloadingAgent.__init__
     monkeypatch.setattr(
         DownloadingAgent,
         "__init__",
-        lambda self, repo, **kw: built.append(kw.get("subfolder")) or original(self, repo, **kw),
+        lambda self, repo, **kw: (
+            built.append(kw.get("subfolder")) or original(self, repo, **kw)
+        ),
     )
     Repository.device = {"typed-decisions": "cpu"}
     with pytest.raises(RuntimeError):
-        router.predict("refund me", {"r": {"type": "noul", "instructions": "?"}}, model="typed-decisions")
-    assert built == ["typed-decisions", "multilingual"] and router.loaded == ["multilingual"]
+        router.predict(
+            "refund me",
+            {"r": {"type": "noul", "instructions": "?"}},
+            model="typed-decisions",
+        )
+    assert built == ["typed-decisions", "multilingual"] and router.loaded == [
+        "multilingual"
+    ]
 
 
 def test_describe_reads_the_weight_dtype_from_the_model_as_it_is():
     import torch
 
     agent = FakeAgent()
-    assert engine.describe(agent, "mps", None)["weights_dtype"] is None  # no model to read
+    # no model to read
+    assert engine.describe(agent, "mps", None)["weights_dtype"] is None
     agent.model = torch.nn.Linear(2, 2)
     assert engine.describe(agent, "mps", None)["weights_dtype"] == "torch.float32"
     agent.model.half()
@@ -740,16 +950,24 @@ def test_apply_says_whether_the_options_were_applied(monkeypatch):
     assert optimize.apply(FakeAgent(device="mps"), fp16=True, compile=False) is True
 
 
-def test_the_checkpoint_is_built_once_and_serves_every_request(laya_router, monkeypatch):
+def test_the_checkpoint_is_built_once_and_serves_every_request(
+    laya_router, monkeypatch
+):
     router, revisions = laya_router
     router.preload(["english"])
     built = []
     original = DownloadingAgent.__init__
     monkeypatch.setattr(
-        DownloadingAgent, "__init__", lambda self, repo, **kw: built.append(repo) or original(self, repo, **kw)
+        DownloadingAgent,
+        "__init__",
+        lambda self, repo, **kw: built.append(repo) or original(self, repo, **kw),
     )
     client = TestClient(worker.build_app(router, "english", "mps", revisions=revisions))
-    body = {"model": "english", "state": "refund me", "questions": {"r": {"type": "noul", "instructions": "?"}}}
+    body = {
+        "model": "english",
+        "state": "refund me",
+        "questions": {"r": {"type": "noul", "instructions": "?"}},
+    }
     for _ in range(3):
         response = client.post("/v1/systemone", json=body)
         assert response.status_code == 200 and response.json()["answers"]["r"] == ANSWER
@@ -761,12 +979,16 @@ def test_main_binds_only_after_every_warmup_request(monkeypatch):
     bound_after = []
     monkeypatch.setattr(worker, "make_router", lambda device, model: router)
     monkeypatch.setattr(worker.logging, "basicConfig", lambda **kw: None)
-    monkeypatch.setattr("uvicorn.run", lambda app, **kw: bound_after.append(len(router.calls)))
+    monkeypatch.setattr(
+        "uvicorn.run", lambda app, **kw: bound_after.append(len(router.calls))
+    )
     monkeypatch.setattr(sys, "argv", ["laya_mps", "--device", "mps"])
     worker.main()
     assert bound_after == [len(engine.WARMUP_SHAPES) * engine.WARMUP_REPEATS]
 
 
 def test_the_warmup_asks_every_question_type():
-    kinds = {q["type"] for _, questions in engine.WARMUP_SHAPES for q in questions.values()}
+    kinds = {
+        q["type"] for _, questions in engine.WARMUP_SHAPES for q in questions.values()
+    }
     assert kinds == {"choice", "score", "noul"}