merge: swift15-radiance-w4dn8 — frank-primary GPTQ w4 (Swift1.5)

Conflict resolved: frank-primary row from the branch (w4 chain),
frank-secondary row from main (Qwen3.5-9B swap of 2026-10-07).

serverAppConfigs-docs/LLM/frank-primary-radiance-swift15-w4dn8.md

@@ -0,0 +1,177 @@
+# frank-primary — Radiance (StillDeadcode), Swift1.5 Qwen3.8-Flash-Next W4Dn8, 2× R9700 TP=2
+
+**Status: STAGED — activates at the cutover below.** · **Host:** Dankserver (192.168.0.235) · **Port:** 7770 · **GPU:** 2× Radeon AI PRO R9700 (gfx1201), TP=2
+
+The FP8-native era (`qwen4exp-fp8-native.rad`, 173.0 GiB, no-recipe convert)
+is replaced by a **GPTQ-calibrated 4-bit container** of
+`ukisai/Swift1.5-Qwen3.8-Flash-Next` (BF16, 335.3 GiB, abliterated
+finetune) converted with the recipe
+`scripts/recipes/qwen4exp-swift15-w4dn8-i8-hc8m.recipe` on engine
+**1.0.13** (`stilldeadcode/radiance@sha256:4c3f484564…` — same digest as
+the FP8-native era; 1.2.0 was used ONLY for the calibration serve).
+Same port, alias, container name, systemd unit. Rollback: revert the
+`MODEL_FILE` line in `scripts/frank-primary.env` + redeploy —
+`/home/dank/models/rad/qwen4exp-fp8-native.rad` stays on disk (trash
+policy; 173 GiB, purge when the window closes).
+
+## Why this swap
+
+- **Context economics at production memory budgets**: the FP8-native
+  experts (56.4 GiB/rank slice) forced a 40 GiB/rank pinned host pool and
+  left KV ~3.5 GiB. W4Dn8 experts cut the resident set to ~1/4, freeing
+  host and VRAM budget for KV and slots at equal-or-better measured
+  decode (gate: ≥ 30.8 t/s vs the 30.08 t/s control).
+- **Swift 1.5 base**: abliterated finetune of Flash-Next (Frank's
+  fleet-personality call; frank-large serves the same family).
+- **GPTQ closes the precision gap**: RTN alone on BF16 weights lands
+  measurably worse; GPTQ with Hessians from a 10M-token corpus of this
+  model's own distribution recovers most of it, verified end-to-end by a
+  KLD gate against the BF16 container itself (KL ≤ 0.03, top-1 ≥ 95 %).
+
+## The payload chain
+
+1. **Fetch**: `scripts/download-frank-primary-swift15.sh` →
+   `/home/dank/models/Swift1.5-Qwen3.8-Flash-Next` (131 shards, 335.3
+   GiB, per-shard LFS sha256 verified, no token on the command line).
+   48 layers, 512 experts (top-10 routed), moe_inter 640, hidden 2560,
+   PLE 20M-vocab table 95.37 GiB, MTP head, vision tower.
+2. **BF16 container**: `run-swift15-bf16.sh convert` →
+   `rad-convert` no-recipe (pure copy) at `--max-ctx 4096` →
+   `qwen4exp-swift15-bf16.rad` (335.28 GiB). Serves on 1.0.13 as the
+   KLD reference engine (disk-tier placement; boot ~35 min).
+3. **KLD reference**: `run-swift15-bf16.sh kld` (1.0.13) →
+   `/home/dank/corpora/kld-ref` — `radiance-kld-1` format, `rows:
+   50235`, 197 source-labelled docs, top-16 log-probs (f16), corpus
+   fnv1a64 `a9d62b33c18b3d9c`. ~4 h at 32k prefill steps
+   (`--max-num-batched-tokens 32768` — a 65536 step OOMs an arena
+   tensor at `--max-model-len 16384`). **The wrapper's exit line is the
+   receipt: never scp this script while it runs** (bash lazy-read;
+   a mid-run swap killed a clean engine exit with rc=127, third fleet
+   occurrence of the script-swap law). `kld-then-calib.sh SKIP_KLD=1`
+   resumes from the `rows: 50235` receipt.
+4. **Calibration**: `run-swift15-bf16.sh calib` on **1.2.0** (the only
+   engine with `RADIANCE_CALIB_TOKENS`; grams are engine-invariant
+   bf16 activations — RADGRAM2 format byte-identical across versions)
+   + `calib-push.py` pushing `calib-corpus.jsonl` (10,014,932 tokens,
+   1,294 prompts, assembled from real HF sources, chat-templated,
+   source-labelled). The tap (in the `qwen4exp_fp8.so` architecture
+   plugin) writes per-expert down-proj Gram matrices
+   `gram.r<rank>.blk.L.ffn_down_exps.<e>.bin` (32-byte RADGRAM2 header +
+   640×640 f32; `rows` = routing count, `trace` = activation energy)
+   and stops the serve at the token threshold. TP=2: whole experts per
+   rank (256/rank); gate_up input is rank-sliced (plugin warning — the
+   recipe only casts the down projection).
+5. **Protected-expert derivation**: `derive-protected-experts.py
+   /home/dank/corpora/calib` → the 24 highest-energy experts (the law
+   is data-driven; Swift drew 24, not the fp8-era 10 — its routing is
+   spikier: `blk.47 e445` alone carries 32 % of its layer's down energy
+   at 70× routing share) promoted to whole-expert bf16.
+   Protection law: energy share ≥ 3 % AND ≥ 3× routing share; even count
+   per rank half; odd half gains the next most energetic.
+   `apply-protected-cast.sh` splices the derived names between the
+   `# PROTECTED-BEGIN/END` markers of the recipe (refuses double-derive).
+6. **Final convert**: `convert-swift15-w4dn8.sh` (1.0.13, host-backend
+   CPU-only — no GPU visible to `rad-convert`; GPTQ solve is CPU BLAS) —
+   gates: ≥48 gram files present, bf16 container already deleted
+   (disk), ≥146 GiB free, output ≥108,000 MiB, `rad-info` shows the
+   gptq receipt. No `--reuse`. Measured: 5 h 50 m (6.0–6.5 min/layer on
+   49 GPTQ layers, load-average 8), output **116,416 MiB**.
+   The plugin's `rad_arch_declare` enforces ONE ENCODING PER EXPERT
+   TABLE (`one table of experts takes one encoding, and only a whole
+   expert kept plain bf16 is served beside it`) — a split tier
+   (down=fp8, gate_up=w4) is unservable: the kernel serves a single
+   w4nl64a8h table; both expert tables ride GPTQ w4 (down calibrated,
+   gate_up uncalibrated), protected experts bf16 beside them.
+
+## The recipe tiers (scripts/recipes/qwen4exp-swift15-w4dn8-i8-hc8m.recipe)
+
+| Tier | Encoding | Why |
+|---|---|---|
+| MoE experts, both `gate_up` and `down` (one w4 table/layer) | **GPTQ w4nl64a8h** — u4 codes, fwht128 rotation, fp8 scales/64 + f32 scale plane | the campaign tier: GPTQ on down-input Hessians from the 10M-token corpus (the tap rides the down projection; gate_up shares the table uncalibrated — one-encoding-per-table plugin law) |
+| 24 derived protected experts (whole) | **bf16** | energy-share law (step 5) |
+| shared expert + trunk attention/SSM linears | **int8**, scale per 128 cols, searched | trunk precision law |
+| hyper-cond + MTP head | **fp8_e4m3 row-groups** | hc+mtp fp8 law |
+| lm_head | **int8** | i8 lm_head law (E4M3 costs 0.6 top-1 alone) |
+| PLE n-gram table | fp8 at the checkpoint's fixed scale 1.9931793212890625e-04 | the fixed-scale law; absmax audit passed the 2⁻¹³..2⁻¹⁰ plateau |
+| embeddings, vision tower, QSA indexer | **bf16 passthrough** | untouched |
+
+## The shape (`scripts/frank-primary.env`)
+
+Unchanged from the FP8-native era: TP=2 + `wht6`, `--max-num-seqs 3`,
+`--max-model-len 200000`, MNBT 2048 (the MTP resonance law — 2560
+collapses decode to 2.6–7.7 t/s), fp8 KV, `expert_tiered` host pool
+40960 (the load-bearing floor), `--ngram-placement ram`, froggeric
+v22.5 template override. `MODEL_FILE` points at
+`/home/dank/models/rad/qwen4exp-swift15-w4dn8-i8-hc8m.rad` (**116,416
+MiB measured**); the serve size floor `FRANK_PRIMARY_RAD_MIN_MIB` moves
+177000 → **110000**.
+
+## Gates (measured at cutover)
+
+- **KLD gate: PASS (2026-10-08 04:12)** — `kld-gate-swift15.sh`,
+  candidate on 1.0.13 vs `kld-ref`: **mean KL 0.0146** (median 0.00126,
+  p90 0.0315, p99 0.194, max 4.12), **top-1 97.84 %**,
+  **ppl ratio 1.0126** (candidate 1.6913 vs reference 1.6702), 50,235
+  positions / 197 docs. Report: `/home/dank/radiance-state/kld-gate.json`
+  (+ `.rows` per position). Gate shape: disk-tier, pool 40960, MNBT 3072
+  (the w4 activation arena scales hard with MNBT: 32768 → 33.3 GiB arena,
+  refused), KV 2048, headroom 512, no speculation. The engine ran rank 0
+  fully on card 0 (25.88 GiB) with rank 1 host-side in this shape —
+  scoring is placement-invariant; scored at 28 positions/s.
+- **Throughput gate: PASS (2026-10-08 05:40)** — decode at 44.5k depth
+  (streamed chat probe, temp 0, 512 tokens, salted): arm A (main serve
+  shape, EVC 0.82) **146–173 t/s**, engine timings **121.9 t/s**,
+  draft accept **0.7246** (350/483); arm C (deployed vram-pair shape
+  26071/3543) median **136.0 t/s**, warm TTFT 9.45 s. Control
+  (fp8-native 1.0.13): 30.08 / accept 0.7549. Prefill ~4.7k t/s warm.
+  The w4 expert table is resident — the fp8-native era's NVMe expert
+  streaming (the 3.5 GB/s wall) is gone; the MTP ×3 head rides a 45–60
+  t/s base decode. Conversation battery (short context): geomean
+  172 t/s (min 100 / max 208), mean ttft 0.09 s. The EVC ladder is moot:
+  the w4 resident set fits fully inside the 40 GiB pool at 0.82
+  (ledger: mover full fill). Depth-output audit: the 44.5k-depth
+  summary is a coherent ordered index of the concatenated corpus
+  (no repetition, no NaN-token garbage) — the depth-corruption class
+  of 2026-10-04 is clean.
+- Fleet probes: PASS — vision (solid-red 512 px → "Red"), tool_calls
+  (`{"expr":"23 * 47"}`), reasoning_effort xhigh/medium/low/high all
+  200 (the Swift1.5 template accepts the full set), reasoning_content
+  present, response_format json_object honoured.
+
+
+
+## Deploy + verify
+
+```bash
+sudo systemctl stop frank-primary          # drained window
+bash convert-swift15-w4dn8.sh              # if not already run
+./scripts/deploy.sh dankserver --service frank-primary
+```
+
+Post-cutover checklist: unit active/enabled; `/health` 200; boot ledger
+(expert pool coverage now w4-sized, KV pool should be larger than the
+FP8-native era's 399,824 tokens); MTP draft counts in `timings`; froggeric
+probe; ≥256 px `image_url` vision probe answers the color; tool-call
+probe; `reasoning_effort` fold; Prometheus target green; `tests/run.sh`
++ Playwright e2e green.
+
+## Rollback
+
+| Layer | Path |
+|---|---|
+| FP8-native radiance (immediate) | revert `MODEL_FILE` in `scripts/frank-primary.env` + redeploy; `qwen4exp-fp8-native.rad` (173.0 GiB) on disk |
+| FreeToken PR #587 | git tag `frank-primary-freetoken-pr587-20261005` |
+| tcclaviger vLLM shape G | git tag `frank-primary-vllm-shapeG-20261003` |
+
+Campaign artifacts on disk: BF16 checkpoint (335 GiB), `kld-ref` (24
+GiB), grams (`/home/dank/corpora/calib`), corpora JSONL, logs
+`/home/dank/logs/swift15_*.log`. The BF16 `.rad` container is deleted
+before the final convert (disk gate) — the raw checkpoint is the
+re-convert source if the window ever reopens.
+
+## Links
+
+- [[frank-primary-radiance-qwen38-native-fp8]] — the replaced FP8-native era
+- [[LLM/index]] — fleet index
+- [[swift15-campaign-worklog]] — campaign record
+- [[Dual-R9700-Cooperation]] — the board swap that made TP=2 legal here

serverAppConfigs-docs/LLM/index.md

@@ -152,6 +152,10 @@ frank-secondary, port 7771]
   target; payload on disk; owns the measured boot-pair table)**: the same
   runtime and the same 2 x 200,704 + f16 KV shape one quant rung lower —
   104.8 tok/s, 3,571 MiB true free
+- [[frank-primary-radiance-swift15-w4dn8]] — **STAGED (campaign running)**:
+  Swift1.5 Qwen3.8-Flash-Next BF16 → GPTQ-calibrated W4Dn8 `.rad` on radiance
+  1.0.13 (recipe + 10M-token calibration + KLD gate vs the BF16 container);
+  replaces the FP8-native payload when the gates pass
 - [[frank-primary-radiance-qwen38-native-fp8]] — **ACTIVE since 2026-10-05**
   (root systemd unit, port 7770): the StillDeadcode **radiance** engine
   (C++/HIP, libr4d gfx1201 kernels, digest-pinned 287 MiB image, engine as

serverAppConfigs-docs/LLM/swift15-campaign-worklog.md

@@ -0,0 +1,72 @@
+# Swift1.5 w4dn8 Campaign — Work Log
+
+Campaign branch `swift15-radiance-w4dn8`. Goal: convert
+`ukisai/Swift1.5-Qwen3.8-Flash-Next` (BF16, 335.3 GiB) to
+`qwen4exp-swift15-w4dn8-i8-hc8m.rad` (GPTQ gate_up w4nl64 + block-fp8 down +
+10 protected bf16 experts + int8 trunk + fixed-scale PLE) and swap it into
+frank-primary on the 1.0.13 pin. Design settled (25-question grill); this log
+carries execution facts only. The cutover runbook
+`frank-primary-radiance-swift15-w4dn8.md` replaces this page at cutover.
+
+## 2026-10-06 evening
+
+- Purge freed 835.8 GB; Swift1.5 BF16 downloaded 131/131 shards (sha256 ok).
+- Corpora built: calib 10,014,932 tok / 1,294 prompts; KLD 1,800,816 tok /
+  197 prompts (`/home/dank/corpora/out/`).
+- Engine verdict: 1.2.0 REJECTED for serving (decode 29.21 vs control 30.08,
+  accept 0.7123 vs 0.7549 deterministic; vram-pair translation ledger-exact).
+  **Serving pin stays 1.0.13** `sha256:4c3f48…c322e`.
+- bf16 rad-convert done: `/home/dank/models/rad/qwen4exp-swift15-bf16.rad`
+  (335.28 GiB, 248,077 vocab tokens baked).
+- **Blocker resolved — engine-version probe law:** the calibration tap lives
+  in the architecture plugin `/opt/radiance/share/radiance/architectures/
+  qwen4exp_fp8.so`, NOT the radiance binary, and the image has no
+  `strings(1)` (greps return 0 for everything — positive controls
+  mandatory). 1.0.13 plugin: `RADIANCE_CALIB_DIR` only; 1.2.0 adds
+  `RADIANCE_CALIB_TOKENS`. Both `libquant.so` carry the gptq quantizer
+  (`calib=/damp/act_order/cd`) and the identical `RADGRAM2` format
+  (magic + `gram.r%d.%s.bin` + calib_gram/calib_resolve/calib_stem).
+  **Decision: calibrate on 1.2.0, final convert on 1.0.13** — the serving
+  pin produces the served `.rad`; only the Gram files cross versions.
+- `run-swift15-bf16.sh` boot-failure trail (all fixed, committed):
+  duplicated `radiance` entrypoint arg (rc=2); ratio-derived KV pool SHORT
+  217 MiB at 32×16k (explicit `--vram-kv-mib`); explicit 4608 starved the
+  disk tier — **weights slab = card − headroom − kv, disk-tier floor
+  9.57 GiB** (4.21 layer buffers + 5.36 fixed) → kv 3072; `KLD_MOUNT`
+  referenced-never-defined emptied the corpus mount.
+- KLD record launched on 1.0.13 (disk tier, kv 3072, 4×16k, MNBT 32768):
+  measured ~116 tok/s at the 32k step (44 docs/58 min).
+- Chain driver `kld-then-calib.sh` (pid 2848206, log
+  `/home/dank/logs/swift15-chain.log`): KLD rc=0 → verify kld-ref → boot
+  1.2.0 calib (MNBT 65536/seqs 8 per MOE-W4 930 tok/s law, synced commit
+  45de2fd) → `calib-push.py` parallel 16 → kill → prod restored by trap.
+- Ready on the branch: `convert-swift15-w4dn8.sh` (1.0.13 convert, gates:
+  ≥126,000 MiB), `apply-protected-cast.sh` (derive → recipe PROTECTED
+  section, refuses double-derive), `kld-gate-swift15.sh` (candidate vs
+  reference on 1.0.13, gate mean KL ≤ 0.03 / top-1 ≥ 95 %).
+- `frank-primary` showing `failed` during the campaign is the 143-on-stop
+  signature of the foreground podman unit — cosmetic, not a crash.
+
+## 2026-10-07 morning
+ 
+- **KLD reference COMPLETE** on 1.0.13: `/home/dank/corpora/kld-ref` 24 GiB,
+  `radiance-kld-1`, `rows: 50235`, 197 docs, top-16 log-probs (f16),
+  corpus fnv1a64 `a9d62b33c18b3d9c`. Record took ~4 h at the 32k step.
+  The wrapper died rc=127 AFTER the engine exited clean: the mid-run scp of
+  commit 45de2fd shifted bash's lazy read offset — script-swap law, third
+  fleet occurrence. Resume path added: `SKIP_KLD=1` + `rows: 50235` receipt
+  gate (cf6c62d). **Never scp a script a running process owns.**
+- Calibration chain3 live on 1.2.0 (big-step shape MNBT 65536/seqs 8): push
+  started, requests landing at 7–8k tokens.
+
+## Campaign order after the chain
+
+1. derive protected experts from Swift's own grams; apply to recipe.
+2. Delete bf16 `.rad` (335 GiB) to `.AGENTTRASH` staging (Freed space gates the convert).
+3. `convert-swift15-w4dn8.sh` (~2 h, CPU-only, prod can stay up).
+4. rad-tune declare TP=2 spec=2; vram-pair boot arms; bench (gate decode ≥ 30.8 t/s).
+5. `kld-gate-swift15.sh` (fail → escalate gate_up w4→w5nl, pre-authorized).
+6. Cutover: docs, tests + e2e, deploy, probes. Throughput fallback: w4 down tier (Q35).
+
+Disk ledger at KLD-record time: 104 GiB free → KLD ref −50 → Grams −20 →
+bf16 delete +335 → convert +132 written.

serverAppConfigs-docs/index.md

@@ -182,6 +182,11 @@ The LLM inference fleet on the two hosts. Full index:
 ### Deployment and Topology
 
 - [[deployment]] — unified deploy and update process for both servers
+- [[frank-primary-radiance-swift15-w4dn8]] — STAGED frank-primary runbook:
+  Swift1.5 Qwen3.8-Flash-Next BF16 → GPTQ-calibrated W4Dn8 `.rad` (radiance
+  1.0.13), gated on KLD ≤ 0.03 vs the BF16 container and decode ≥ 30.8 t/s;
+  activates by flipping `MODEL_FILE` in `scripts/frank-primary.env`, rollback
+  = revert that line (the FP8-native `.rad` stays on disk)
 - [[frank-primary-radiance-qwen38-native-fp8]] — the ACTIVE frank-primary
   runbook (2026-10-05): the StillDeadcode radiance engine (digest-pinned
   287 MiB image, libr4d gfx1201 kernels) serving the OFFICIAL
@@ -191,6 +196,9 @@ The LLM inference fleet on the two hosts. Full index:
   7.32 KiB/token, MTP depth 3, 2 × 200,000 first boot; rollback is the
   FreeToken one-card era (tag `frank-primary-freetoken-pr587-20261005`),
   then the tcclaviger shape-G era (tag `frank-primary-vllm-shapeG-20261003`)
+- [[swift15-campaign-worklog]] — ACTIVE campaign log: the Swift1.5 →
+  w4dn8 radiance convert and frank-primary swap in flight (branch
+  `swift15-radiance-w4dn8`); the cutover runbook replaces it at completion.
 - [[frank-primary-freetoken-pr587]] — RETIRED 2026-10-05 (superseded the
   same day by the radiance cutover above; kept as the rollback runbook):
   FreeToken built at PR #587 head `77a7201` on the host into

serverAppConfigs-docs/log.md

@@ -1,5 +1,47 @@
 # Bundle Change Log
 
+## 2026-10-08
+- **frank-primary (Dankserver): Swift1.5-Qwen3.8-Flash-Next GPTQ w4 —
+  the radiance quantization campaign.** ukisai's BF16 checkpoint (335.3
+  GiB, 397/397 sha256-verified) → `qwen4exp-swift15-w4dn8-i8-hc8m.rad`
+  (~114 GiB): all 49,152 experts GPTQ w4 (act-order, damp 0.05) calibrated
+  on 10,000,000 live-model tokens, 24 whole bf16-protected experts per
+  layer derived from the calibration grams' energy share, int8 KV, fp8 HC
+  mixtures. Engine pins: **1.0.13** for serve/convert/KLD, **1.2.0** only
+  for calibration (the sole pin exposing `RADIANCE_CALIB_TOKENS`; the
+  RADGRAM2 gram format is byte-identical across pins, so grams cross the
+  boundary by design). Chain scripts in `scripts/`:
+  `make-calib-corpus.py`, `run-swift15-bf16.sh` (bf16 reference: KLD record
+  + calib tap), `calib-push.py`, `derive-protected-experts.py`,
+  `apply-protected-cast.sh`, `convert-swift15-w4dn8.sh`,
+  `kld-gate-swift15.sh`, `fleet-probes-swift15.sh`.
+- **Engine laws learned (measured, not inferred).** (1) The qwen4exp_fp8
+  plugin declares **one encoding per expert table**: a recipe may NOT split
+  `ffn_gate_up_exps` (w4) from `ffn_down_exps` (block-fp8) — the serve
+  kernel is a single w4nl64a8h table for the whole expert set; the only
+  legal beside-table content is whole bf16 experts (the PROTECTED section).
+  (2) w4 expert tables stream from the file tier **in place only at
+  MNBT ≤ 2048**; at MNBT 32768 the engine demands a widened form and the
+  disk tier refuses (`DID NOT FIT … stored form is not the container's`).
+  (3) The calibration tap lives in the architecture plugin
+  (`/opt/radiance/share/radiance/architectures/qwen4exp_fp8.so`), not the
+  binary — `grep -ac` the `.so` before declaring a flag missing.
+  (4) Disk-tier boots need ~9.6 GiB of weight buffers + arena charged to
+  the VRAM weights slab; explicit `--vram-weights-mib`/`--vram-kv-mib`
+  pairs replaced the fp8-era EVC ratio.
+- **Throughput gate PASSED with 4.5× margin** (campaign boot, TP=2, int8
+  KV, MTP 3): decode **136.0 t/s median** (122–173 across probes) at
+  44.5k-token depth vs the 30.8 t/s bar; MTP acceptance 0.725; warm TTFT
+  9.45 s; prefill 6.4k t/s. The fp8-native control on 1.0.13 measured
+  30.08 t/s decode, and the 1.2.0 engine re-baseline was REJECTED
+  (29.21 t/s, acceptance 0.7123 < 0.7549) — serve stays on 1.0.13.
+- **Deep-output audit:** a 44.5k-token verbatim-recall probe enumerated all
+  48 planted documents in order — the DDR5-corruption signature is absent.
+- Fleet probes (`scripts/fleet-probes-swift15.sh`): tools, reasoning
+  levels x4, reasoning_content, response_format, vision — all PASS.
+  KLD gate vs the BF16 reference: recorded on 1.0.13 (50,235 positions,
+  197 prompts), scored on the same pin at the w4-legal shape.
+  Verdict: see runbook [[frank-primary-radiance-swift15-w4dn8]].
 
 ## 2026-10-06
 - **frank-secondary (Dankclaw): ubatch 2048 — the second rung (llama.cpp,