frank-small: double the compute-buffer pair to 4096/2048

BATCH_SIZE 2048 -> 4096, UBATCH_SIZE 1024 -> 2048.

Why the ubatch move is right on THIS card: the prefill curve is
card-specific. On the 2x R9700 layer-split sibling it peaks at ubatch 512
and every step up costs GiB for no speed; on this CUDA 3090 it climbs
monotonically to 2048 (710 -> 1188 t/s on the 35B MoE sweep, 1944 -> 2423
t/s on the Ornith 8k sweep) with decode flat to under 1 t/s on every rung.
The logical batch is free either way: two sweeps agree that at a fixed
ubatch, 2048/4096/8192 give identical prefill speed and identical peak
VRAM, because the compute buffers are sized by the ubatch alone.

The risk is all in the ubatch, and it is documented rather than assumed:
the step cost ~1,244 MiB of peak graph VRAM on the 35B MoE, the shape this
replaces is 2,815 MiB free, and the Q5_K_M predecessor recorded "ubatch
2048 failed the scratch boot" with MORE free than that. Compute buffers
are allocated at graph capture during boot, so a failure is loud and fast;
the step-down rungs (4096/1536, then 4096/1024) are named in the env.

The seam stops hard-coding a rung: serve_argv now carries BATCH_SIZE and
UBATCH_SIZE the way it already carried CTX_SIZE et al., and the pair test
asserts the argv follows the shipped env plus the llama.cpp invariant
ubatch <= batch. Verified both ways: retuning the env to 8192/4096 keeps
the seam green, inverting the pair to 2048/4096 turns it red.

scripts/frank-small.env

@@ -72,12 +72,32 @@ CTX_SIZE=401408
 PARALLEL=2
 
 # Compute-buffer geometry. This endpoint passed neither flag until 2026-10-03,
-# so it ran on llama.cpp's own defaults (2048/512); the fleet now asks for a
-# 1024 ubatch on this shape. Both are tunables because the pair is a
-# measurement, not a law: on the 27B sibling 512 was the prefill peak and every
-# step up cost GiB of compute buffer for no speed.
-BATCH_SIZE=2048
-UBATCH_SIZE=1024
+# so it ran on llama.cpp's own defaults (2048/512); the pair is now 4096/2048.
+# Both are tunables because the pair is a measurement, not a law — and the
+# measurement is CARD-SPECIFIC. On the 2x R9700 layer-split sibling the ubatch
+# curve peaks at 512 and every step up costs GiB of compute buffer for no
+# speed (see frank-medium-batch-ubatch). On THIS CUDA 3090 the curve climbs
+# monotonically to 2048: 710 -> 1188 t/s prefill from ubatch 1024 to 2048 on
+# the 35B MoE sweep, 1944 -> 2423 t/s on the Ornith 8k sweep, with decode flat
+# to under 1 t/s on every rung. Ubatch is a prefill knob; decode never moves.
+#
+# The logical batch is free — two independent sweeps agree that at a fixed
+# ubatch, 2048/4096/8192 give identical prefill speed AND identical peak VRAM,
+# because the compute buffers are sized by the ubatch alone. Doubling it costs
+# nothing and buys nothing; it is here because it is the value the pair was
+# measured at.
+#
+# THE RISK IS ALL IN THE UBATCH. The 1024 -> 2048 step cost ~1,244 MiB of peak
+# graph VRAM on the 35B MoE (7,330 -> 8,574 MiB); this 9B hybrid has far
+# smaller compute tensors, so the delta should be well under that, but the
+# predecessor Q5_K_M shape recorded "ubatch 2048 failed the scratch boot" at
+# ~3,571 MiB free. This shape ships with LESS free (2,815 MiB measured
+# 2026-10-05). Compute buffers are allocated at graph capture during BOOT, so
+# a failure is loud and fast, not a surprise at the first long prompt. MEASURE
+# nvidia-smi free immediately after the deploy: under ~1.5 GiB, or a boot
+# failure, step down to 4096/1536 (or 4096/1024, the last known-good rung).
+BATCH_SIZE=4096
+UBATCH_SIZE=2048
 
 # The KV contract (Frank, 2026-10-03): unquantized K AND V. --flash-attn stays
 # pinned on in the serve script — it is what made the q8_0-V path cheap and it

scripts/serve-frank-small.sh

@@ -45,10 +45,13 @@ fi
 : "${CTX_SIZE:=401408}"
 : "${PARALLEL:=2}"
 # Compute-buffer geometry. Before 2026-10-03 this endpoint never passed either
-# flag, so it ran on llama.cpp's own defaults (2048/512); they are tunables now
-# because the 1024 ubatch is what this shape was booted with.
-: "${BATCH_SIZE:=2048}"
-: "${UBATCH_SIZE:=1024}"
+# flag, so it ran on llama.cpp's own defaults (2048/512). The pair is 4096/2048
+# since 2026-10-05: on this CUDA card the prefill curve climbs all the way to
+# ubatch 2048 (unlike the R9700 layer-split sibling, where 512 is the peak),
+# and the logical batch is VRAM- and throughput-neutral. frank-small.env
+# carries the sweep tables and the VRAM risk note.
+: "${BATCH_SIZE:=4096}"
+: "${UBATCH_SIZE:=2048}"
 : "${CACHE_TYPE_K:=f16}"
 : "${CACHE_TYPE_V:=f16}"
 : "${NGL:=99}"

tests/frank_small_unit.bats

@@ -52,6 +52,8 @@ BIND_ADDR=0.0.0.0
 LISTEN_PORT=7771
 CTX_SIZE=$(sed -nE 's/^CTX_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
 PARALLEL=$(sed -nE 's/^PARALLEL=([0-9]+)$/\1/p' "$ENV_FILE")
+BATCH_SIZE=$(sed -nE 's/^BATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
+UBATCH_SIZE=$(sed -nE 's/^UBATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
 CACHE_TYPE_K=$(sed -nE 's/^CACHE_TYPE_K=(.+)$/\1/p' "$ENV_FILE")
 CACHE_TYPE_V=$(sed -nE 's/^CACHE_TYPE_V=(.+)$/\1/p' "$ENV_FILE")
 NGL=$(sed -nE 's/^NGL=([0-9]+)$/\1/p' "$ENV_FILE")
@@ -150,14 +152,31 @@ argv_value() {
     [ $((native * 33 / 1048576 + 9)) -gt 24 ]
 }
 
-@test "the compute-buffer pair is explicit" {
-    # This endpoint ran on llama.cpp's own defaults until 2026-10-03; the
-    # fleet now pins 2048/1024 so the number a benchmark attributes the
-    # prefill rate to is a repo value, not an engine default nobody wrote down.
+@test "the compute-buffer pair follows the env file and stays self-consistent" {
+    # This endpoint ran on llama.cpp's own defaults until 2026-10-03, so the
+    # contract is: whatever rung the repo carries is the rung the engine is
+    # exec'd with — the number a benchmark attributes a prefill rate to must be
+    # a repo value, never an engine default nobody wrote down. Asserted against
+    # the env rather than a literal so a retune moves one file, not two.
+    local env_batch env_ubatch
+    env_batch="$(sed -nE 's/^BATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
+    env_ubatch="$(sed -nE 's/^UBATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
     serve_argv
     [ "$status" -eq 0 ]
-    [ "$(argv_value --batch-size)" = "2048" ]
-    [ "$(argv_value --ubatch-size)" = "1024" ]
+    [ "$(argv_value --batch-size)" = "$env_batch" ]
+    [ "$(argv_value --ubatch-size)" = "$env_ubatch" ]
+    # llama.cpp refuses ubatch > batch, so a retune that inverts the pair has
+    # to fail here instead of at boot on a live endpoint.
+    [ "$env_batch" -ge "$env_ubatch" ]
+
+    # And an env that names neither flag still ships an explicit pair: the
+    # serve script's fallbacks are written-down values, not blanks the engine
+    # fills in silently.
+    sed -i '/^BATCH_SIZE=/d;/^UBATCH_SIZE=/d' "$STAGE/test.env"
+    serve_argv
+    [ "$status" -eq 0 ]
+    argv_value --batch-size | grep -qE '^[0-9]+$'
+    argv_value --ubatch-size | grep -qE '^[0-9]+$'
 }
 
 @test "no speculative draft ships by default" {