frank-small: Frank overrules q8_0 V — f16 K+V, ubatch 1024 first, ONE native 262144 slot (the only f16/f16 shape that fits Q8 weights on 24 GiB)

tests/frank_small_unit.bats

@@ -100,7 +100,7 @@ argv_value() {
     done
 }
 
-@test "the shipped env serves the fleet shape: two 200704-token contexts" {
+@test "the shipped env serves the fleet shape: one native 262144-token context" {
     serve_argv
     [ "$status" -eq 0 ]
     [ "$(argv_value --alias)" = "frank-small" ]
@@ -110,49 +110,54 @@ argv_value() {
     [ "$(argv_value --n-gpu-layers)" -gt 0 ]
     # llama.cpp divides --ctx-size across slots and a mamba hybrid cannot
     # share one cache, so the observable contract is the per-slot window.
-    [ "$(argv_value --parallel)" -eq 2 ]
+    # 2026-10-05 (Frank): NO KV quantization forces ONE slot at the NATIVE
+    # window — Ornith's 9 full-attn layers price f16 KV at 36 KiB/token, and
+    # two 200,704 slots cannot fit the 2-3 GiB floor on 24 GiB with Q8
+    # weights. The window per conversation ROSE 200,704 -> 262,144.
+    [ "$(argv_value --parallel)" -eq 1 ]
     ctx="$(argv_value --ctx-size)"
     par="$(argv_value --parallel)"
     [ $((ctx % par)) -eq 0 ]
-    [ $((ctx / par)) -eq 200704 ]
-    [ $((ctx / par)) -le 262144 ]
+    [ $((ctx / par)) -eq 262144 ]
 }
 
-@test "the KV contract is f16 K + q8_0 V, flash-attn on" {
+@test "the KV contract is unquantized both halves, flash-attn on" {
     serve_argv
     [ "$status" -eq 0 ]
     [ "$(argv_value --cache-type-k)" = "f16" ]
-    # Frank, 2026-10-05 (1862dc3): the Ornith payload has NINE full-attention
-    # layers (18 KiB/token/half) and +1,900 MiB of weights vs MiMo Q6_K, so
-    # f16/f16 lands ~379 MiB free — a dead boot; q8_0 V keeps 2 x 200,704
-    # AND the 2-3 GiB floor. The flag pair is what makes this observable — a
-    # build without the FA path silently falls back, so both must appear in
-    # the argv the supervisor runs.
-    [ "$(argv_value --cache-type-v)" = "q8_0" ]
+    # Frank, 2026-10-05: NO KV quantization on this endpoint. The Q8_0 rung
+    # funds itself by UBATCH first (2048 -> 1024), then pool steps — a q8_0-V
+    # proposal was written and overruled. The flag pair is what makes this
+    # observable — a build without the FA path silently falls back, so both
+    # must appear in the argv the supervisor runs.
+    [ "$(argv_value --cache-type-v)" = "f16" ]
     [ "$(argv_value --flash-attn)" = "on" ]
 }
 
 @test "the KV budget leaves 2-3 GiB of the 3090 free" {
-    # Rate, from the GGUF geometry: 8 full-attention layers x 4 kv heads x
-    # 256 dim x 2 B = 16 KiB/token for K and the same for V => 32 KiB/token
-    # (budgeted 33 with slack). The non-KV half is MEASURED on this card on
-    # 2026-10-02: with the projector loaded the engine reported 22,972 MiB
-    # used against 14,113 MiB of KV, so weights + vision tower + DeltaNet
-    # state + compute buffers + CUDA graphs = 8,859 MiB => 9 GiB. Two asserts,
-    # both about the output the operator sees: the pool must still fit with
-    # 2 GiB spare, and it must be large enough that 5 GiB spare is NOT
-    # reachable (an undersized pool is as wrong as an oversized one).
+    # Rate, from the Ornith GGUF header (read from the Hub file, 2026-10-05):
+    # NINE full-attention layers (block_count 33, full_attention_interval 4)
+    # x 4 kv heads x 256 dim x 2 B = 18 KiB/token for K and the same for V
+    # => 36 KiB/token (budgeted 37 with slack; MiMo measured 24.5 — one
+    # fewer layer AND one fewer KV head). The non-KV half: Q8_0 weights
+    # 9,334 MiB (9,786,060,384 B) + vision tower ~1.3 GiB (mmproj 879 MiB at
+    # the measured ~1.5x cost law) + DeltaNet state + compute buffers +
+    # CUDA graphs => 11 GiB budgeted. Two asserts, both about the output
+    # the operator sees: the pool must still fit with 2 GiB spare, and it
+    # must be large enough that 5 GiB spare is NOT reachable (an undersized
+    # pool is as wrong as an oversized one).
     # Arithmetic, not a boot log: change CTX_SIZE and this bites before the
-    # deploy does. The same pool with the OLD 24.5 KiB/token rate would leave
-    # ~6 GiB free — i.e. the unquantized V is what puts this shape in the band.
+    # deploy does. At Ornith's rate the two-200704-slot pool (14.1 GiB KV)
+    # FAILS the first assert — which is exactly why the shipped shape is
+    # ONE native slot.
     ctx="$(sed -nE 's/^CTX_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
-    kv_gib=$((ctx * 33 / 1048576))
-    [ $((kv_gib + 9 + 2)) -le 24 ]
-    [ $((kv_gib + 9 + 5)) -gt 24 ]
+    kv_gib=$((ctx * 37 / 1048576))
+    [ $((kv_gib + 11 + 2)) -le 24 ]
+    [ $((kv_gib + 11 + 5)) -gt 24 ]
     # And the ceiling that sets the per-slot window: two NATIVE windows cannot
     # be paid for in full precision on this card.
     native=$((2 * 262144))
-    [ $((native * 33 / 1048576 + 9)) -gt 24 ]
+    [ $((native * 37 / 1048576 + 11)) -gt 24 ]
 }
 
 @test "the compute-buffer pair follows the env file and stays self-consistent" {