frank-medium: llama.cpp layer split across both R9700s, DFlash2 drafting

The vllm-radiance replica pair could not use both cards for one model: TP=2
needs a cross-card collective and the second R9700 cannot dispatch one. The
same wall blocks vLLM's pipeline parallelism, whose stage handoff is an RCCL
send/recv of the hidden state (distributed/parallel_state.py) -- a fact worth
writing down, because the obvious reading of the ask ('use PP to dodge the
atomics problem') is exactly backwards.

llama.cpp's layer split needs no collective at all: layers are distributed and
the boundary activation is a per-backend copy, once per forward pass. One
process, both cards, one model. The runtime is mainline llama.cpp at fb27a525
(the ref is pinned by DFlash2 AND qwen35 MTP; the ROCmFPX fork this host had
before has neither), built for gfx1201 against the private ROCm 7.14 toolchain
the earlier build already used, and bundled next to the binary.

Server: ajgazin Swift-Qwen3.8-27B-Uncensored UD-Q8_K_XL with the model's MTP
head in the file, plus the z-lab DFlash2 Q8_0 block-diffusion drafter at depth
7 (its block is 8, so 7 is the ceiling llama.cpp allows). Text only: vision
stays on frank-small.

Retired into the trash rather than deleted: the three vLLM quadlets, the
radiance entrypoint/healthcheck, the routing proxy and its tests, and the two
bench scripts that drove 'vllm bench serve' inside the retired image. The
deploy handler now stops them, waits for 7770 to be released, installs the
ROOT unit and refuses to start anything when the runtime or payload is
missing. The planner maps the scripts/ trio to frank-medium only, and the
scoping seam asserts the retired service dir is gone rather than merely
unmapped.

dankserver/.AGENTTRASH/20260916-vllm-radiance/affinity-proxy.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""HTTP front door for the frank-medium single-GPU replicas.
+
+Why two replicas instead of TP=2: one vLLM process spanning both R9700s needs
+RCCL collectives, and RCCL's kernels require PCIe atomics on every
+participating GPU. The second card sits behind chipset bridges advertising
+`AtomicOpsCap: Routing-`, which no software can enable (see the runbook), so
+no collective can launch on it. Two single-GPU replicas use both cards; this
+service keeps the fleet contract of one endpoint on :7770, streaming included.
+
+Routing decisions live in routing.py — spread single-turn requests, pin
+continuations to the replica whose prefix cache holds their context. This file
+only moves bytes: parse enough of the request to route it, forward it verbatim,
+stream the answer back, and report replica health on /health.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from contextlib import suppress
+from aiohttp import ClientSession, ClientTimeout, web
+
+import routing
+
+PORT = int(os.environ.get("PORT", "7770"))
+HEALTH_TTL = float(os.environ.get("HEALTH_TTL", "10"))
+# Hop-by-hop headers must not be forwarded (RFC 9110 §7.6.1) — forwarding
+# transfer-encoding or content-length of a rewritten body breaks clients.
+HOP_BY_HOP = {
+    "host", "content-length", "transfer-encoding", "connection",
+    "keep-alive", "proxy-authenticate", "proxy-authorization", "te",
+    "trailers", "upgrade",
+}
+
+UPSTREAMS = routing.UPSTREAMS
+# Replica health, refreshed by the watcher. Module state rather than aiohttp app
+# state: the application is frozen once the site is up.
+_UP: list[bool] = [True] * len(UPSTREAMS)
+
+
+async def health(session: ClientSession) -> web.Response:
+    results = await asyncio.gather(
+        *(session.get(u + "/health", timeout=ClientTimeout(total=5)) for u in UPSTREAMS),
+        return_exceptions=True,
+    )
+    lines, up = [], 0
+    for url, res in zip(UPSTREAMS, results):
+        if isinstance(res, Exception) or res.status != 200:
+            lines.append(f"{url} DOWN")
+        else:
+            up += 1
+            lines.append(f"{url} UP")
+    return web.Response(status=200 if up else 503, text="\n".join(lines) + "\n")
+
+
+async def watch_health() -> None:
+    """Refresh the replica up/down table so routing never targets a dead one.
+
+    One HTTP request per replica per interval, in exchange for never handing a
+    client a 502 after a restart.
+    """
+    global _UP
+    session = ClientSession()
+    try:
+        while True:
+            res = await asyncio.gather(
+                *(session.get(u + "/health", timeout=ClientTimeout(total=5)) for u in UPSTREAMS),
+                return_exceptions=True,
+            )
+            _UP = [not isinstance(r, Exception) and r.status == 200 for r in res]
+            await asyncio.sleep(HEALTH_TTL)
+    finally:
+        await session.close()
+
+
+async def proxy(request: web.Request) -> web.StreamResponse:
+    session: ClientSession = request.app["session"]
+    if request.path == "/health":
+        return await health(session)
+
+    body = await request.read()
+    headers = {k: v for k, v in request.headers.items() if k.lower() not in HOP_BY_HOP}
+
+    # Fail over before anything is written to the client. A replica that
+    # restarts is invisible to the health watcher for up to HEALTH_TTL, and a
+    # deploy restarts both replicas — without this retry a 10 s window of
+    # requests would 502 on a service that has a live card the whole time.
+    # vLLM's OpenAI endpoints are stateless per request, so re-sending a
+    # request that never reached an engine is safe; a request that failed
+    # mid-stream is not retried (that path is below).
+    tried: set[int] = set()
+    upstream = None
+    last_error = "no healthy frank-medium replica"
+    while len(tried) < len(UPSTREAMS):
+        idx = routing.route(body, request.remote, _UP)
+        if idx < 0 or idx in tried:
+            break
+        tried.add(idx)
+        target = UPSTREAMS[idx] + request.path_qs
+        try:
+            upstream = await session.request(
+                request.method, target, headers=headers, data=body or None,
+                timeout=ClientTimeout(total=None, sock_connect=10, sock_read=3600),
+            )
+            break
+        except Exception as exc:
+            # Demote at once: the watcher will confirm, but every request until
+            # then should skip this replica rather than pay the same timeout.
+            # Logged because a silent failover hides a card that is down.
+            _UP[idx] = False
+            last_error = f"{target} unreachable: {exc}"
+            print(f"proxy: failover — {target} unreachable ({exc}); retrying "
+                  f"another replica", flush=True)
+    if upstream is None:
+        # 503 when no replica was even reachable through the routing table,
+        # 502 when replicas were tried and all of them failed.
+        status = 502 if tried else 503
+        return web.Response(status=status, text=f"proxy: {last_error}\n")
+
+    out = web.StreamResponse(status=upstream.status, reason=upstream.reason)
+    for k, v in upstream.headers.items():
+        if k.lower() not in HOP_BY_HOP:
+            out.headers[k] = v
+    await out.prepare(request)
+    try:
+        async for chunk in upstream.content.iter_any():
+            await out.write(chunk)
+    except Exception:
+        # The client went away mid-stream (an aborted generation). Nothing to
+        # report: the engine sees its own cancellation.
+        pass
+    finally:
+        upstream.release()
+    with suppress(Exception):
+        await out.write_eof()
+    return out
+
+
+async def main() -> None:
+    app = web.Application(client_max_size=1024 ** 3)
+    app["session"] = ClientSession()
+    app.router.add_route("*", "/{tail:.*}", proxy)
+    runner = web.AppRunner(app)
+    await runner.setup()
+    await web.TCPSite(runner, "0.0.0.0", PORT).start()
+    print(f"proxy: :{PORT} -> {', '.join(UPSTREAMS)} routing={routing.ROUTING} "
+          f"key={routing.AFFINITY_BYTES}B known_max={routing.KNOWN_MAX}", flush=True)
+    watcher = asyncio.create_task(watch_health())
+    with suppress(asyncio.CancelledError):
+        await asyncio.gather(watcher)
+
+
+if __name__ == "__main__":
+    with suppress(KeyboardInterrupt):
+        asyncio.run(main())

dankserver/.AGENTTRASH/20260916-vllm-radiance/frank-medium-a.container

@@ -0,0 +1,98 @@
+# Quadlet unit: frank-medium replica A (rootless, boot-persistent).
+#
+# Install path on dankserver: ~/.config/containers/systemd/frank-medium-a.container
+# Unit name: frank-medium-a.service (container name: frank-medium-a)
+#
+# WHY TWO REPLICAS INSTEAD OF TP=2. The intended shape for frank-medium is one
+# tensor-parallel process across both R9700s (see frank-medium.container, kept
+# as the target). That shape cannot run on this host: RCCL's collective kernels
+# carry a hidden hostcall-buffer parameter, and the ROCr runtime refuses to
+# dispatch them on a device without PCIe atomics ("Pcie atomics not enabled,
+# hostcall not supported" -> AQL dispatch failed -> hipErrorIllegalState). The
+# second R9700 sits behind the chipset bridges 05:00.0/06:09.0, which advertise
+# `AtomicOpsCap: Routing-` — a read-only capability, so no software can enable
+# atomics on that path; the amdgpu driver's pci_enable_atomic_ops_to_root()
+# therefore fails for that GPU and KFD marks the CPU<->GPU2 link NO_ATOMICS.
+# The first R9700 sits on CPU root port 00:01.1 (Routing+) and does have
+# atomics. Result: every collective that touches GPU 2 dies at launch.
+# Two independent single-GPU replicas use both cards instead; the proxy unit
+# keeps the single :7770 endpoint. Full evidence: the frank-medium runbook.
+#
+# SHAPE. vLLM binds 0.0.0.0:7771 on the host network directly; no PublishPort.
+# MAXLEN is 114688, not the TP=2 deployment's 262144: one card carries the
+# whole model (~20 GiB of weights + drafter), leaving ~5.2 GiB of KV, and
+# 131072 does not fit (measured: needs 5.58 GiB). KV_MEM=0 lets vLLM profile
+# this shape instead of using the 2x7551-32624 pin, which is only valid at
+# TP=2/262144.
+#
+# DEVICES. /dev/kfd + /dev/dri; HIP_VISIBLE_DEVICES=0 (the first R9700). The
+# 2 GiB Raphael iGPU enumerates as index 2 and is excluded by the pin.
+# Only HIP_VISIBLE_DEVICES is set, never ROCR_VISIBLE_DEVICES: ROCR filters
+# first and HIP indexes into the filtered list, so a single-valued pair
+# (ROCR=1,HIP=1) leaves an empty device set.
+#
+# DO NOT name an environment variable TEMP, HOST or GPU_MAX_HEAP_SIZE: the
+# HIP runtime reads bare TEMP for its JIT cache path (2026-08-13 incident).
+[Unit]
+Description=frank-medium replica A — vllm-radiance MXFP4 Qwen3.8-27B on R9700 #1
+After=network-online.target
+
+[Container]
+ContainerName=frank-medium-a
+Image=localhost/radiance-vllm:0.9.3
+AddDevice=/dev/kfd
+AddDevice=/dev/dri
+GroupAdd=keep-groups
+# The upstream launcher's exact podman posture (rootless).
+PodmanArgs=--privileged --ipc=host --security-opt seccomp=unconfined --cap-add SYS_PTRACE --network=host
+Environment=HIP_VISIBLE_DEVICES=0
+Environment=SNAP=/models/Qwen3.8-27B-Uncensored-MXFP4-awq
+Environment=DRAFTER=/models/Qwen3.8-27B-DFlash2-FP8
+Environment=CHAT_TEMPLATE=/patches/qwen-fixed-v22.3.jinja
+Environment=SERVED_NAMES=frank-medium
+Environment=PORT=7771
+Environment=TP=1
+Environment=MAXSEQS=4
+Environment=CHUNK=8192
+Environment=MAXLEN=114688
+Environment=GPU_UTIL=0.98
+Environment=KV_MEM=0
+Environment=SPEC_METHOD=dflash
+Environment=SPEC=7
+# Checkpoints (rw: nothing downloads at runtime, but vLLM mmaps the shards).
+Volume=/home/dank/models:/models
+# Tokenizer files ride the HF cache; HF_HUB_OFFLINE=1 is set in the entrypoint.
+Volume=/home/dank/.cache/huggingface:/root/.cache/huggingface
+# Compile cache. Shared with the other replica and with the TP=2 target: the
+# entries are content-addressed, so shapes simply add subdirectories.
+Volume=/home/dank/.radiance-cache-w4a8-093-gdnm-nqft-fp8s-gnq:/cache
+# The pinned radiance clone: patches applied at every container start.
+Volume=/home/dank/GitPackages/radiance-vllm-mxfp4:/patches:z
+# The patched libr4d (pin b9e42ab + repo extras, key b9e42ab-rx6). The image's
+# shipped r4d.so predates the GDN overflow fix and NaNs this model.
+Volume=/home/dank/.cache/radiance-libr4d/b9e42ab-rx6:/r4d:z
+# Entrypoint + healthcheck from this checkout, mounted read-only.
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/radiance-entrypoint.sh:/usr/local/bin/frank-medium-entrypoint.sh:ro
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/frank-medium-healthcheck.py:/usr/local/bin/frank-medium-healthcheck.py:ro
+# The entrypoint must be the container command; the image's own entrypoint
+# (which the patched script execs at the end) must not run unpatched.
+PodmanArgs=--entrypoint /usr/local/bin/frank-medium-entrypoint.sh
+# 200 only once the engine serves; during first-start compilation the
+# container is legitimately unhealthy. HealthCmd is split on spaces into an
+# argv array by the podman 5.x v1 generator, hence the file-based probe.
+HealthCmd=python3 /usr/local/bin/frank-medium-healthcheck.py
+HealthInterval=60s
+HealthTimeout=30s
+HealthRetries=3
+HealthStartPeriod=1800s
+Pull=never
+
+[Service]
+# First start compiles Triton/inductor kernels (several minutes) before the
+# engine loads ~20 GiB of weights.
+TimeoutStartSec=1800
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target

dankserver/.AGENTTRASH/20260916-vllm-radiance/frank-medium-b.container

@@ -0,0 +1,98 @@
+# Quadlet unit: frank-medium replica B (rootless, boot-persistent).
+#
+# Install path on dankserver: ~/.config/containers/systemd/frank-medium-b.container
+# Unit name: frank-medium-b.service (container name: frank-medium-a)
+#
+# WHY TWO REPLICAS INSTEAD OF TP=2. The intended shape for frank-medium is one
+# tensor-parallel process across both R9700s (see frank-medium.container, kept
+# as the target). That shape cannot run on this host: RCCL's collective kernels
+# carry a hidden hostcall-buffer parameter, and the ROCr runtime refuses to
+# dispatch them on a device without PCIe atomics ("Pcie atomics not enabled,
+# hostcall not supported" -> AQL dispatch failed -> hipErrorIllegalState). The
+# second R9700 sits behind the chipset bridges 05:00.0/06:09.0, which advertise
+# `AtomicOpsCap: Routing-` — a read-only capability, so no software can enable
+# atomics on that path; the amdgpu driver's pci_enable_atomic_ops_to_root()
+# therefore fails for that GPU and KFD marks the CPU<->GPU2 link NO_ATOMICS.
+# The first R9700 sits on CPU root port 00:01.1 (Routing+) and does have
+# atomics. Result: every collective that touches GPU 2 dies at launch.
+# Two independent single-GPU replicas use both cards instead; the proxy unit
+# keeps the single :7770 endpoint. Full evidence: the frank-medium runbook.
+#
+# SHAPE. vLLM binds 0.0.0.0:7772 on the host network directly; no PublishPort.
+# MAXLEN is 114688, not the TP=2 deployment's 262144: one card carries the
+# whole model (~20 GiB of weights + drafter), leaving ~5.2 GiB of KV, and
+# 131072 does not fit (measured: needs 5.58 GiB). KV_MEM=0 lets vLLM profile
+# this shape instead of using the 2x7551-32624 pin, which is only valid at
+# TP=2/262144.
+#
+# DEVICES. /dev/kfd + /dev/dri; HIP_VISIBLE_DEVICES=1 (the second R9700). The
+# 2 GiB Raphael iGPU enumerates as index 2 and is excluded by the pin.
+# Only HIP_VISIBLE_DEVICES is set, never ROCR_VISIBLE_DEVICES: ROCR filters
+# first and HIP indexes into the filtered list, so a single-valued pair
+# (ROCR=1,HIP=1) leaves an empty device set.
+#
+# DO NOT name an environment variable TEMP, HOST or GPU_MAX_HEAP_SIZE: the
+# HIP runtime reads bare TEMP for its JIT cache path (2026-08-13 incident).
+[Unit]
+Description=frank-medium replica B — vllm-radiance MXFP4 Qwen3.8-27B on R9700 #2
+After=network-online.target
+
+[Container]
+ContainerName=frank-medium-b
+Image=localhost/radiance-vllm:0.9.3
+AddDevice=/dev/kfd
+AddDevice=/dev/dri
+GroupAdd=keep-groups
+# The upstream launcher's exact podman posture (rootless).
+PodmanArgs=--privileged --ipc=host --security-opt seccomp=unconfined --cap-add SYS_PTRACE --network=host
+Environment=HIP_VISIBLE_DEVICES=1
+Environment=SNAP=/models/Qwen3.8-27B-Uncensored-MXFP4-awq
+Environment=DRAFTER=/models/Qwen3.8-27B-DFlash2-FP8
+Environment=CHAT_TEMPLATE=/patches/qwen-fixed-v22.3.jinja
+Environment=SERVED_NAMES=frank-medium
+Environment=PORT=7772
+Environment=TP=1
+Environment=MAXSEQS=4
+Environment=CHUNK=8192
+Environment=MAXLEN=114688
+Environment=GPU_UTIL=0.98
+Environment=KV_MEM=0
+Environment=SPEC_METHOD=dflash
+Environment=SPEC=7
+# Checkpoints (rw: nothing downloads at runtime, but vLLM mmaps the shards).
+Volume=/home/dank/models:/models
+# Tokenizer files ride the HF cache; HF_HUB_OFFLINE=1 is set in the entrypoint.
+Volume=/home/dank/.cache/huggingface:/root/.cache/huggingface
+# Compile cache. Shared with the other replica and with the TP=2 target: the
+# entries are content-addressed, so shapes simply add subdirectories.
+Volume=/home/dank/.radiance-cache-w4a8-093-gdnm-nqft-fp8s-gnq:/cache
+# The pinned radiance clone: patches applied at every container start.
+Volume=/home/dank/GitPackages/radiance-vllm-mxfp4:/patches:z
+# The patched libr4d (pin b9e42ab + repo extras, key b9e42ab-rx6). The image's
+# shipped r4d.so predates the GDN overflow fix and NaNs this model.
+Volume=/home/dank/.cache/radiance-libr4d/b9e42ab-rx6:/r4d:z
+# Entrypoint + healthcheck from this checkout, mounted read-only.
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/radiance-entrypoint.sh:/usr/local/bin/frank-medium-entrypoint.sh:ro
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/frank-medium-healthcheck.py:/usr/local/bin/frank-medium-healthcheck.py:ro
+# The entrypoint must be the container command; the image's own entrypoint
+# (which the patched script execs at the end) must not run unpatched.
+PodmanArgs=--entrypoint /usr/local/bin/frank-medium-entrypoint.sh
+# 200 only once the engine serves; during first-start compilation the
+# container is legitimately unhealthy. HealthCmd is split on spaces into an
+# argv array by the podman 5.x v1 generator, hence the file-based probe.
+HealthCmd=python3 /usr/local/bin/frank-medium-healthcheck.py
+HealthInterval=60s
+HealthTimeout=30s
+HealthRetries=3
+HealthStartPeriod=1800s
+Pull=never
+
+[Service]
+# First start compiles Triton/inductor kernels (several minutes) before the
+# engine loads ~20 GiB of weights.
+TimeoutStartSec=1800
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target

dankserver/.AGENTTRASH/20260916-vllm-radiance/frank-medium-healthcheck.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""frank-medium container healthcheck: the port's /health must answer 200.
+
+Runs INSIDE the container. The vLLM /health endpoint only answers once the
+engine is up (weights loaded, cudagraphs captured), so a healthy container is
+a serving container, not merely a live process. PORT selects the endpoint so
+the single-GPU replicas (:7771/:7772) and the round-robin proxy (:7770) can
+share this probe. The HealthCmd in the quadlet splits on spaces into an argv
+array (podman 5.x v1 generator), which is why this lives in a file rather
+than an inline python one-liner.
+"""
+import os
+import sys
+import urllib.request
+
+port = os.environ.get("PORT", "7770")
+try:
+    with urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=5) as r:
+        sys.exit(0 if r.status == 200 else 1)
+except Exception:
+    sys.exit(1)

dankserver/.AGENTTRASH/20260916-vllm-radiance/frank-medium-proxy.container

@@ -0,0 +1,61 @@
+# Quadlet unit: frank-medium proxy (rootless, boot-persistent).
+#
+# Install path on dankserver: ~/.config/containers/systemd/frank-medium-proxy.container
+# Unit name: frank-medium-proxy.service (container name: frank-medium-proxy)
+#
+# WHAT IT IS. A prefix-affinity reverse proxy in front of the two single-GPU
+# frank-medium replicas (:7771 on R9700 #1, :7772 on R9700 #2). It preserves
+# the fleet contract: one endpoint on host port 7770 answering as the served
+# model name frank-medium, OpenAI /v1, streaming included.
+#
+# WHY IT EXISTS. TP=2 — one vLLM process spanning both cards — is impossible
+# on this host (see frank-medium-a.container and the runbook: RCCL's kernels
+# need PCIe atomics, and the second card's chipset path advertises
+# AtomicOpsCap: Routing-). Two replicas are how both cards get used.
+#
+# ROUTING. Requests are keyed on a hash of their leading 4 KiB of prompt text,
+# so a conversation family — an agent loop re-sending the same system prompt,
+# tool list and file context every turn — keeps landing on the same replica,
+# where --enable-prefix-caching has that prefix warm. Plain round-robin threw
+# half of those cache hits away. A replica that is down is skipped, and
+# ROUTING=roundrobin restores the old behaviour for A/B measurement. /health
+# answers 200 while at least one replica is up and names the ones that are
+# down. The proxy runs on host networking so it can bind 7770 and reach the
+# replicas on loopback.
+#
+# The script is a few dozen lines of aiohttp, mounted read-only out of
+# /home/dank/serverAppConfigs (deploy.sh pulls that checkout before dispatch).
+# It reuses the same image as the replicas: aiohttp is already there and no
+# extra image has to be pulled on this host.
+[Unit]
+Description=frank-medium proxy — prefix-affinity in front of the two single-GPU replicas
+After=network-online.target
+Wants=frank-medium-a.service frank-medium-b.service
+After=frank-medium-a.service frank-medium-b.service
+
+[Container]
+ContainerName=frank-medium-proxy
+Image=localhost/radiance-vllm:0.9.3
+PodmanArgs=--network=host
+Environment=PORT=7770
+Environment=UPSTREAMS=http://127.0.0.1:7771,http://127.0.0.1:7772
+# The proxy is two files: routing.py holds the replica-selection policy, the
+# server holds the HTTP plumbing. Both are mounted because the server imports
+# the policy by name from its own directory (/usr/local/bin is sys.path[0]).
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/proxy/routing.py:/usr/local/bin/routing.py:ro
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/proxy/affinity-proxy.py:/usr/local/bin/affinity-proxy.py:ro
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/frank-medium-healthcheck.py:/usr/local/bin/frank-medium-healthcheck.py:ro
+PodmanArgs=--entrypoint /usr/local/bin/affinity-proxy.py
+HealthCmd=python3 /usr/local/bin/frank-medium-healthcheck.py
+HealthInterval=60s
+HealthTimeout=30s
+HealthRetries=3
+HealthStartPeriod=60s
+Pull=never
+
+[Service]
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target

dankserver/.AGENTTRASH/20260916-vllm-radiance/frank-medium.container

@@ -0,0 +1,147 @@
+# Quadlet unit: frank-medium (rootless, boot-persistent).
+#
+# Install path on dankserver: ~/.config/containers/systemd/frank-medium.container
+# Unit name: frank-medium.service (container name: frank-medium)
+#
+# The dankserver LLM endpoint (:7770, alias frank-medium), since 2026-09-15
+# running the vllm-radiance MXFP4 stack (stilldeadcode/vllm-radiance:0.9.3
+# image + the ggz14/radiance-vllm-mxfp4 patches) serving
+# just1moremodel/Qwen3.8-27B-Uncensored-MXFP4-awq on the 2x Radeon AI PRO
+# R9700 (gfx1201) cards. It replaced the charlie12345/ROCmFPX llama.cpp
+# deployment, which served the same alias from the Q8_0_ROCMFPX_AGENT GGUF;
+# the MXFP4 stack is tensor-parallel (TP=2, R4D one-shot all-reduce) with the
+# DFlash2-FP8 block-diffusion drafter (SPEC=7) — the measured production
+# configuration of the upstream repo, on our exact hardware signature
+# (2x7551-32624, see the KV pin below).
+#
+# SHAPE. The launcher the upstream repo ships binds the server with
+# --network=host (vLLM takes --host 0.0.0.0 --port 7770 directly), which is
+# what this unit does too — no PublishPort. The fleet contract is unchanged:
+# :7770, served model name frank-medium (SERVED_NAMES), OpenAI /v1.
+#
+# NOT INSTALLED ON THIS HOST. This is the target shape: one tensor-parallel
+# process across both R9700s. It cannot launch a collective here — RCCL's
+# kernels need PCIe atomics and the second card sits behind chipset bridges
+# advertising `AtomicOpsCap: Routing-` — so the active deployment is the
+# two-replica trio in this directory (frank-medium-a/b/proxy) and
+# deploy-remote.sh deliberately does not install this unit. Keep it for a
+# host whose second card is on an atomic-capable root port; the full evidence
+# is in serverAppConfigs-docs/LLM/frank-medium-radiance-mxfp4.md.
+#
+# DEVICES. /dev/kfd + /dev/dri through the amdgpu/KFD stack; HIP/ROCR device
+# indices 0,1 (the two R9700s). The 2 GiB Raphael iGPU enumerates as index 2
+# and is excluded both by the index pin and by the upstream MIN_GPU_MIB=8192
+# logic this unit replaces. --privileged --ipc=host --security-opt
+# seccomp=unconfined --cap-add SYS_PTRACE is the upstream launcher's exact
+# podman posture.
+#
+# MOUNTS. /models (rw checkpoints), the HF cache (tokenizer files),
+# /cache (Triton/inductor/aiter/vLLM compile cache — first start compiles for
+# several minutes, later starts reuse), /patches (the pinned radiance clone —
+# its patches are applied at EVERY container start by the entrypoint), /r4d
+# (the patched libr4d build; the image's shipped r4d.so NaNs the
+# gated-delta-net and must never be used), and the entrypoint + healthcheck
+# scripts from this checkout (mounted read-only straight out of
+# /home/dank/serverAppConfigs — deploy.sh git-pulls the checkout before
+# dispatching).
+#
+# IMAGE. The unit runs the localhost/-aliased tag: this host's podman quadlet
+# path cannot resolve registry-prefixed refs from local storage at create
+# time (same as frank-large on dankclaw). deploy-remote.sh pulls the
+# docker.io ref and re-tags it before the restart. Pull=never keeps boots off
+# the registry.
+#
+# KEEP IN SYNC: the radiance clone is pinned (97353293...); if it is updated,
+# re-diff dankserver/frank-medium/radiance-entrypoint.sh against the new
+# serve-mxfp4.sh container command and bump the pin deliberately.
+#
+# DO NOT name an environment variable TEMP, HOST or GPU_MAX_HEAP_SIZE: the
+# HIP runtime reads bare TEMP for its JIT cache path (2026-08-13 incident).
+[Unit]
+Description=frank-medium — vllm-radiance MXFP4 Qwen3.8-27B-Uncensored on 2x R9700 (gfx1201)
+After=network-online.target
+
+[Container]
+ContainerName=frank-medium
+Image=localhost/radiance-vllm:0.9.3
+# vLLM binds 0.0.0.0:7770 on the host network directly; no PublishPort.
+AddDevice=/dev/kfd
+AddDevice=/dev/dri
+GroupAdd=keep-groups
+# The upstream launcher's exact podman posture (rootless; podman-only flags
+# like --replace are not needed under systemd management).
+PodmanArgs=--privileged --ipc=host --security-opt seccomp=unconfined --cap-add SYS_PTRACE --network=host
+# The two R9700s. The Raphael iGPU (index 2, 2 GiB) stays out: shared system
+# memory is not a compute target.
+Environment=ROCR_VISIBLE_DEVICES=0,1
+Environment=HIP_VISIBLE_DEVICES=0,1
+# The uncensored MXFP4 checkpoint ships its fp8 MTP head already, so no
+# fp8_mtp.py rewrite step exists or is needed (unlike amd/Qwen3.8-27B-Quark-AWQ-MXFP4).
+Environment=SNAP=/models/Qwen3.8-27B-Uncensored-MXFP4-awq
+Environment=DRAFTER=/models/Qwen3.8-27B-DFlash2-FP8
+Environment=CHAT_TEMPLATE=/patches/qwen-fixed-v22.3.jinja
+# Fleet identity: the id at /v1/models and in every response body. Every
+# client (Hermes, the harness, services.json) points at frank-medium.
+Environment=SERVED_NAMES=frank-medium
+Environment=PORT=7770
+# Fixed 2-card tensor parallel: the tested configuration of the upstream
+# repo; the R4D one-shot all-reduce kernel serves it natively.
+Environment=TP=2
+# Measured production batch shape (upstream README): MAXSEQS 8 peaks
+# aggregate throughput at 573 t/s; MAXLEN is the model's native context.
+Environment=MAXSEQS=8
+Environment=CHUNK=8192
+Environment=MAXLEN=262144
+Environment=GPU_UTIL=0.98
+# Speculative decoding: the DFlash2 drafter at depth 7 is the configuration
+# every published number (224 t/s single-stream decode, 4749-4810 t/s
+# prefill) was measured with.
+Environment=SPEC_METHOD=dflash
+Environment=SPEC=7
+# KV cache pin, bytes. From the upstream repo's shipped kv-profiles.tsv row
+#   sig=2x7551-32624 maxseqs=8 chunk=8192 maxlen=262144 spec=dflash
+# which is EXACTLY this host (2x R9700 DID 0x7551, 32624 MiB each). Pinned
+# explicitly because this unit does not run the launcher's lookup; valid
+# only at this batch shape (change MAXSEQS/CHUNK/SPEC_METHOD => recalibrate
+# with calibrate-kv.sh or set KV_MEM=0 to let vLLM profile). Worth
+# 943,581 KV tokens vs ~892,799 profiled (~5.7%).
+Environment=KV_MEM=18563072000
+# Checkpoints (rw: nothing downloads at runtime, but vLLM mmaps the shards;
+# keep parity with the launcher's rw mount).
+Volume=/home/dank/models:/models
+# Tokenizer files ride the HF cache; HF_HUB_OFFLINE=1 is set in the
+# entrypoint.
+Volume=/home/dank/.cache/huggingface:/root/.cache/huggingface
+# Compile cache. Keyed on model + stack version + every graph-changing knob;
+# never share it across configurations (upstream rule).
+Volume=/home/dank/.radiance-cache-w4a8-093-gdnm-nqft-fp8s-gnq:/cache
+# The pinned radiance clone: patches applied at every container start.
+Volume=/home/dank/GitPackages/radiance-vllm-mxfp4:/patches:z
+# The patched libr4d (pin b9e42ab + repo extras, key b9e42ab-rx6). The
+# image's shipped r4d.so predates the GDN overflow fix and NaNs this model.
+Volume=/home/dank/.cache/radiance-libr4d/b9e42ab-rx6:/r4d:z
+# Entrypoint + healthcheck from this checkout, mounted read-only.
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/radiance-entrypoint.sh:/usr/local/bin/frank-medium-entrypoint.sh:ro
+Volume=/home/dank/serverAppConfigs/dankserver/frank-medium/frank-medium-healthcheck.py:/usr/local/bin/frank-medium-healthcheck.py:ro
+# The entrypoint must be the container command; the image's own entrypoint
+# (which the patched script execs at the end) must not run unpatched.
+PodmanArgs=--entrypoint /usr/local/bin/frank-medium-entrypoint.sh
+# 200 only once the engine serves; during first-start compilation the
+# container is legitimately unhealthy. HealthCmd is split on spaces into an
+# argv array by the podman 5.x v1 generator, hence the file-based probe.
+HealthCmd=python3 /usr/local/bin/frank-medium-healthcheck.py
+HealthInterval=60s
+HealthTimeout=30s
+HealthRetries=3
+HealthStartPeriod=1800s
+Pull=never
+
+[Service]
+# First start compiles Triton/inductor kernels (several minutes) before the
+# engine loads ~9.5 GiB of weights per card.
+TimeoutStartSec=1800
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target

dankserver/.AGENTTRASH/20260916-vllm-radiance/radiance-entrypoint.sh

@@ -0,0 +1,229 @@
+#!/usr/bin/env bash
+# frank-medium container entrypoint: vllm-radiance MXFP4 on 2x Radeon AI PRO
+# R9700 (gfx1201), serving just1moremodel/Qwen3.8-27B-Uncensored-MXFP4-awq.
+#
+# This is a fork of the patch-and-serve block inside radiance-vllm-mxfp4's
+# serve-mxfp4.sh (clone at /home/dank/GitPackages/radiance-vllm-mxfp4, pinned
+# commit 9735329348ae1c9319f01cbe5f7004ec5f4dba63). The published image alone
+# is NOT sufficient for this model: the shipped libr4d predates the
+# gated-delta-net overflow fix and NaNs the output, and the MXFP4 gates need
+# relaxing, so the repo's patches are applied at every container start from
+# the /patches mount. It runs INSIDE the container (executed as the image
+# command by the frank-medium quadlet); the launcher's host-side GPU/TP/KV
+# detection is not needed here because this fleet is fixed 2x gfx1201 and the
+# KV pin is pinned explicitly in the quadlet.
+#
+# KEEP IN SYNC: if the radiance clone is updated, re-diff this file against
+# the new serve-mxfp4.sh container command and against the DRY_RUN output.
+#
+# Env contract: every knob below is ${VAR:-default}; the quadlet sets the
+# fleet-specific ones (SNAP, PORT, SERVED_NAMES, TP, KV_MEM, ...).
+set -euo pipefail
+
+# ---------------------------------------------------------------- serving shape
+: "${SNAP:=/models/Qwen3.8-27B-Uncensored-MXFP4-awq}"
+: "${DRAFTER:=/models/Qwen3.8-27B-DFlash2-FP8}"
+: "${CHAT_TEMPLATE:=/patches/qwen-fixed-v22.3.jinja}"
+: "${PORT:=7770}"
+: "${SERVED_NAMES:=frank-medium}"
+: "${MAXLEN:=262144}"
+: "${MAXSEQS:=8}"
+# KV_MEM=0 is passed THROUGH as --kv-cache-memory 0, which the image's
+# patched KV sizing reads as "profile the shape" (the launcher's rule).
+# Blanking the variable instead omits the flag and makes vLLM size the cache
+# from --gpu-memory-utilization alone: measured on the single-GPU replicas
+# that overshoots and the allocation dies with torch.OutOfMemoryError right
+# after the weights load (2.16 GiB requested, 116 MiB free). Do not "fix"
+# this into an empty expansion.
+: "${KV_MEM:=18563072000}"   # shipped kv-profiles.tsv row 2x7551-32624 @ 8/8192/262144/dflash
+: "${SPEC_METHOD:=dflash}"
+if [ "$SPEC_METHOD" = dflash ]; then : "${SPEC:=7}"; else : "${SPEC:=4}"; fi
+: "${MIN_M:=0}"              # 0 = the W4A8 kernel serves every M (MIN_M=1 still routes M=1 to aiter)
+: "${R4D_ATTN:=1}"
+: "${ASYNC:=0}"
+
+if [ "$R4D_ATTN" = "1" ]; then ATTN=R4D; else ATTN=ROCM_AITER_UNIFIED_ATTN; fi
+if [ "$ASYNC" = 1 ]; then ASYNC_FLAG="--async-scheduling"; UNPAD=false; else
+  ASYNC_FLAG="--no-async-scheduling"; UNPAD=true; fi
+
+# Drafting config. dflash: the DFlash2-FP8 block-diffusion drafter (its
+# attention backend must support full cuda graphs -> TRITON_ATTN). The
+# disable_padded_drafter_batch unpad is the single-stream lever (~+50%).
+if [ "$SPEC_METHOD" = dflash ]; then
+  if [ ! -f "$DRAFTER/config.json" ]; then
+    echo "frank-medium: no dflash drafter at $DRAFTER" >&2
+    exit 1
+  fi
+  DRAFT_SAMPLE=${DRAFT_SAMPLE:-greedy}
+  SPEC_CFG="{\"method\":\"dflash\",\"model\":\"$DRAFTER\",\"num_speculative_tokens\":$SPEC,\"attention_backend\":\"TRITON_ATTN\",\"disable_padded_drafter_batch\":$UNPAD,\"draft_sample_method\":\"$DRAFT_SAMPLE\"}"
+  RADIANCE_DRAFT_RERANK=${RADIANCE_DRAFT_RERANK:-80}
+  RADIANCE_VERIFY_HEAD=${RADIANCE_VERIFY_HEAD:-1}
+else
+  SPEC_CFG="{\"method\":\"mtp\",\"num_speculative_tokens\":$SPEC,\"attention_backend\":\"$ATTN\",\"disable_padded_drafter_batch\":$UNPAD}"
+  RADIANCE_DRAFT_RERANK=${RADIANCE_DRAFT_RERANK:-32}
+  RADIANCE_VERIFY_HEAD=${RADIANCE_VERIFY_HEAD:-0}
+fi
+
+# The AR size gate compares raw bf16 bytes: CHUNK x hidden(5120) x 2. Derived
+# so changing CHUNK cannot silently drop prefill back onto RCCL.
+export RADIANCE_AR_MAX_KB=$(( (CHUNK * 5120 * 2) / 1024 + 4096 ))
+
+# ---------------------------------------------------------------- runtime env
+export HF_HUB_OFFLINE=1
+export VLLM_LOGGING_LEVEL=${VLLM_LOGGING_LEVEL:-INFO}
+export VLLM_NO_USAGE_STATS=${VLLM_NO_USAGE_STATS:-1}
+export VLLM_ROCM_USE_AITER=1 VLLM_ROCM_USE_AITER_UNIFIED_ATTENTION=1
+export VLLM_ROCM_USE_AITER_MHA=0 VLLM_ROCM_USE_AITER_MLA=0 VLLM_ROCM_USE_AITER_MOE=0
+export VLLM_ROCM_USE_AITER_LINEAR=0 VLLM_ROCM_USE_AITER_FP8BMM=0
+export VLLM_ROCM_USE_AITER_FP4BMM=0 VLLM_ROCM_USE_AITER_RMSNORM=0
+export NCCL_PROTO=Simple
+export RADIANCE_USE_R4D=${RADIANCE_USE_R4D:-1} RADIANCE_USE_R4D_AR=${RADIANCE_USE_R4D_AR:-1}
+export RADIANCE_DFLASH_SELECTOR_TOPK="${RADIANCE_DFLASH_SELECTOR_TOPK:-}"
+export RADIANCE_R4D_REPORT=1
+export RADIANCE_PRESHUFFLE=${RADIANCE_PRESHUFFLE:-1}
+export RADIANCE_MXFP4_SANITIZE="${RADIANCE_MXFP4_SANITIZE:-0}"
+export RADIANCE_MXFP4=1 RADIANCE_MXFP4_W4A8=1 RADIANCE_MXFP4_W4A8_MIN_M="$MIN_M"
+export RADIANCE_FAST_DRAFT=${RADIANCE_FAST_DRAFT:-1}
+export RADIANCE_DRAFT_TAU=${RADIANCE_DRAFT_TAU:-0.20}
+export RADIANCE_DRAFT_RERANK
+export RADIANCE_VERIFY_HEAD
+export RADIANCE_VERIFY_HEAD_MAX_M=${RADIANCE_VERIFY_HEAD_MAX_M:-32}
+export RADIANCE_MXFP4_DEBUG=${RADIANCE_MXFP4_DEBUG:-0}
+export RADIANCE_MXFP4_PUREQUANT=${RADIANCE_MXFP4_PUREQUANT:-0}
+export RADIANCE_MXFP4_SYNC=${RADIANCE_MXFP4_SYNC:-0}
+export RADIANCE_MXFP4_CLONE=${RADIANCE_MXFP4_CLONE:-0}
+export RADIANCE_MXFP4_CHECKX=${RADIANCE_MXFP4_CHECKX:-0}
+export RADIANCE_MXFP4_PADOUT=${RADIANCE_MXFP4_PADOUT:-0}
+export RADIANCE_MXFP4_TN4_MIN_M=${RADIANCE_MXFP4_TN4_MIN_M:-2048}
+# The decode-kernel band must cover MAXSEQS x (SPEC+1) rows: 64 covers 8x8.
+if [ "${MAXSEQS}" -gt 8 ]; then
+  export RADIANCE_MXFP4_DECODE_MAX_M=${RADIANCE_MXFP4_DECODE_MAX_M:-128}
+fi
+export RADIANCE_MXFP4_DECODE_NT=${RADIANCE_MXFP4_DECODE_NT:-1}
+export RADIANCE_MXFP4_A_TILED_MIN_M=${RADIANCE_MXFP4_A_TILED_MIN_M:-513}
+export RADIANCE_MXFP4_WPERM=${RADIANCE_MXFP4_WPERM:-1}
+export RADIANCE_TP_PAD=${RADIANCE_TP_PAD:-0}   # TP=2 here; 3 is the only non-zero value upstream supports
+export RADIANCE_TP_PAD_DRAFTER=${RADIANCE_TP_PAD_DRAFTER:-1}
+export RADIANCE_TP_PAD_STRICT=${RADIANCE_TP_PAD_STRICT:-1}
+export RADIANCE_GDN_MERGE_INPROJ=${RADIANCE_GDN_MERGE_INPROJ:-1}
+export RADIANCE_GDN_NORM_QUANT=${RADIANCE_GDN_NORM_QUANT:-1}
+export RADIANCE_GDN_STRIDED_GATES=${RADIANCE_GDN_STRIDED_GATES:-0}
+export RADIANCE_GDN_EMPTY_OUT=${RADIANCE_GDN_EMPTY_OUT:-0}
+export R4D_ATTN_FP8=${R4D_ATTN_FP8:-3}
+export RADIANCE_DFLASH_CALIB="${RADIANCE_DFLASH_CALIB:-}"
+export RADIANCE_DFLASH_CALIB_TOKENS="${RADIANCE_DFLASH_CALIB_TOKENS:-200000}"
+export RADIANCE_MXFP4_SHADOW="${RADIANCE_MXFP4_SHADOW:-}"
+export RADIANCE_MXFP4_KERNEL_N="${RADIANCE_MXFP4_KERNEL_N:-}"
+export RADIANCE_MXFP4_KERNEL_NK="${RADIANCE_MXFP4_KERNEL_NK:-}"
+export RADIANCE_MXFP4_CHECKALL="${RADIANCE_MXFP4_CHECKALL:-}"
+export RADIANCE_MXFP4_DECODE_KS="${RADIANCE_MXFP4_DECODE_KS:-}"
+export RADIANCE_MXFP4_DECODE_BK="${RADIANCE_MXFP4_DECODE_BK:-}"
+export RADIANCE_MXFP4_PERBLOCK_NK="${RADIANCE_MXFP4_PERBLOCK_NK:-}"
+export RADIANCE_MXFP4_REFLINEAR="${RADIANCE_MXFP4_REFLINEAR:-0}"
+export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-}"
+export RADIANCE_MXFP4_EPIFAST="${RADIANCE_MXFP4_EPIFAST:-1}"
+export RADIANCE_AR_OVERLAP=${RADIANCE_AR_OVERLAP:-0}
+export RADIANCE_GDN_FUSED_UPDATE=${RADIANCE_GDN_FUSED_UPDATE:-1}
+export RADIANCE_DYNAMIC_WIDTH=${RADIANCE_DYNAMIC_WIDTH:-1}
+export RADIANCE_DYNW_ALPHA=${RADIANCE_DYNW_ALPHA:-0.35}
+export RADIANCE_DYNW_MARGIN=${RADIANCE_DYNW_MARGIN:-2}
+export RADIANCE_DYNW_MIN=${RADIANCE_DYNW_MIN:-2}
+export RADIANCE_DYNW_MIN_BATCH=${RADIANCE_DYNW_MIN_BATCH:-3}
+export RADIANCE_AR_QNB=${RADIANCE_AR_QNB:-96}
+export RADIANCE_AR_QNT=${RADIANCE_AR_QNT:-1024}
+export MXFP4_CUMODE=${MXFP4_CUMODE:-0}
+export RADIANCE_STEP_TRACE=${RADIANCE_STEP_TRACE:-0}
+export RADIANCE_AR_OVERLAP_MIN_M=${RADIANCE_AR_OVERLAP_MIN_M:-2048}
+export RADIANCE_AR_OVERLAP_SLICES=${RADIANCE_AR_OVERLAP_SLICES:-4}
+export RADIANCE_MXFP4_EPIFAST=${RADIANCE_MXFP4_EPIFAST:-1}
+export RADIANCE_MXFP4_R4D_DECODE_MAX_M=${RADIANCE_MXFP4_R4D_DECODE_MAX_M:-0}
+export RADIANCE_TOPK_TRITON_MIN_ROWS=${RADIANCE_TOPK_TRITON_MIN_ROWS:-1}
+export RADIANCE_SKINNY_GEMM=${RADIANCE_SKINNY_GEMM:-1}
+export RADIANCE_MXFP4_HOIST_QUANT=${RADIANCE_MXFP4_HOIST_QUANT:-1}
+export RADIANCE_MXFP4_TRACED_QUANT=${RADIANCE_MXFP4_TRACED_QUANT:-1}
+export RADIANCE_FP8_STREAM=${RADIANCE_FP8_STREAM:-1}
+export RADIANCE_RMS_QUANT_FUSION=${RADIANCE_RMS_QUANT_FUSION:-1}
+export RADIANCE_NVFP4_MXFP4=${RADIANCE_NVFP4_MXFP4:-0}
+export RADIANCE_NVFP4_EXP=${RADIANCE_NVFP4_EXP:-mse}
+export RADIANCE_NVFP4_FP8_LAYERS=${RADIANCE_NVFP4_FP8_LAYERS:-mxfp4}
+export RADIANCE_NVFP4_BF16_LAYERS=${RADIANCE_NVFP4_BF16_LAYERS:-in_proj_ba}
+export RADIANCE_NVFP4_LMHEAD=${RADIANCE_NVFP4_LMHEAD:-bf16}
+export RADIANCE_GDN_PATHS=${RADIANCE_GDN_PATHS:-both}
+export RADIANCE_GDN_NANTRACE=${RADIANCE_GDN_NANTRACE:-0}
+export RADIANCE_MXFP4_CHECK_MAX_M=${RADIANCE_MXFP4_CHECK_MAX_M:-128}
+export RADIANCE_MXFP4_MHIST=${RADIANCE_MXFP4_MHIST:-0}
+export VLLM_CACHE_ROOT=/cache/vllm
+export TORCHINDUCTOR_CACHE_DIR=/cache/inductor
+export TRITON_CACHE_DIR=/cache/triton
+export AITER_ROOT_DIR=/cache/aiter
+export TRITON_CACHE_AUTOTUNING=1
+# The patched libr4d built by setup-mxfp4.sh, bind-mounted at /r4d.
+R4D_SO=${R4D_SO:-/r4d}
+
+# The norm+quant fusion turns on vLLM's passes (one --compilation-config
+# instance; argparse keeps the last, so entries accumulate into one flag).
+CC_ITEMS=""
+if [ "${RADIANCE_NORMQUANT_FUSION:-1}" != "0" ]; then
+  CC_ITEMS="\"pass_config\":{\"fuse_norm_quant\":true,\"fuse_act_quant\":true}"
+fi
+EXTRA=${EXTRA:-}
+if [ -n "$CC_ITEMS" ]; then
+  EXTRA="$EXTRA --compilation-config {$CC_ITEMS}"
+fi
+
+# ---------------------------------------------------------------- patch block
+# Byte-for-byte the launcher's container-start block. The patches come from
+# the /patches mount (the pinned radiance clone). SP must match the image's
+# venv layout; the image tag is pinned in the quadlet.
+SP=/opt/vllm/lib/python3.12/site-packages
+cd /patches
+python3 patch_quark_mxfp4.py
+python3 patch_nvfp4_mxfp4.py
+python3 patch_tp3_pad.py
+python3 patch_ar_maxbytes.py
+python3 patch_topk_triton_rows.py
+python3 patch_dflash_calib.py
+python3 patch_dflash_mxfp4_kv.py
+python3 patch_rmsquant_fusion.py
+python3 patch_verify_head.py
+python3 patch_kv_group_size.py
+python3 patch_topk_composite.py
+python3 patch_gdn_shared_build.py
+python3 patch_dflash_selector_topk.py
+python3 patch_gdn_merge_inproj.py
+python3 patch_dynwidth.py
+python3 patch_async_dynwidth.py
+python3 patch_step_trace.py
+python3 patch_ar_geometry.py
+python3 patch_ar_3rank.py
+python3 patch_gdn_glue.py
+# Non-fatal: fixes content=null on thinking-off requests; not required to serve.
+python3 patch_qwen3_thinkoff.py \
+  || echo "[radiance] WARNING: thinkoff patch did not apply; thinking-off requests will return empty content"
+cp mxfp4-configs/*.json "$SP"/aiter/ops/triton/configs/gemm/
+cp radiance_preamble.py /opt/radiance_preamble.py
+cp radiance_nvfp4.py radiance_mxfp4.py radiance_gdn.py radiance_rmsquant.py radiance_drafthead.py \
+   radiance_verifyhead.py radiance_gdnmerge.py radiance_aroverlap.py radiance_topk.py \
+   radiance_arnq.py radiance_tp3pad.py "$SP"/
+hipcc -O3 -w -std=c++17 -fPIC -shared --offload-arch=gfx1201 $([ "${MXFP4_CUMODE:-0}" = 1 ] && echo -mcumode) \
+  $(python3 -m pybind11 --includes) radiance_mxfp4_fp8.hip -o "$SP"/radiance_mxfp4_fp8.so
+if [ -n "${R4D_SO:-}" ] && [ -f /r4d/r4d.so ]; then
+  cp /r4d/r4d.so "$SP"/r4d.so
+  echo "[radiance] using patched r4d.so from $R4D_SO"
+fi
+# Leave /patches before exec: a stale radiance_mxfp4_fp8.so there would shadow
+# the one just compiled into site-packages (cwd precedes it on sys.path).
+cd /
+exec /opt/radiance_entrypoint.sh "$SNAP" --served-model-name $SERVED_NAMES \
+  --host 0.0.0.0 --port "$PORT" \
+  --kv-cache-dtype fp8 --tensor-parallel-size "$TP" \
+  --gpu-memory-utilization "$GPU_UTIL" \
+  ${KV_MEM:+--kv-cache-memory "$KV_MEM"} \
+  --max-model-len "$MAXLEN" --max-num-seqs "$MAXSEQS" --max-num-batched-tokens "$CHUNK" \
+  --attention-backend "$ATTN" \
+  --speculative-config "$SPEC_CFG" \
+  $ASYNC_FLAG $EXTRA \
+  --enable-prefix-caching --mamba-cache-mode align --enable-auto-tool-choice \
+  --tool-call-parser qwen3_coder --reasoning-parser qwen3 \
+  --override-generation-config '{"temperature":0.7,"top_p":0.95,"top_k":20}' \
+  --chat-template "$CHAT_TEMPLATE"

dankserver/.AGENTTRASH/20260916-vllm-radiance/routing.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""Routing policy for the frank-medium proxy: which replica serves a request.
+
+Kept apart from the HTTP plumbing in affinity-proxy.py so the decisions can be
+tested without aiohttp, a network or a GPU — the first version of these rules
+shipped with a bug that only appeared on a continuation request, and a test
+that loads this module catches that class of mistake directly.
+
+Two cards, two behaviours, and the workload decides which is right:
+
+* A **single-turn** request is one member of a batch (a benchmark run, a burst
+  of parallel subagents). Spreading those over both replicas lets both cards
+  prefill at once; measured on this host, a 16-request burst of 15k-token
+  prompts finishes in 18.6 s spread versus 30.1 s pinned.
+* A **continuation** re-sends a prefix the replica has already prefilled. Pinned
+  to that replica the turn costs a cache lookup; spread, half the turns pay a
+  cold prefill again (measured: 1096 ms versus 2676 ms mean warm-turn TTFT on
+  90k-token contexts).
+
+ROUTING picks the strategy; the default `adaptive` applies both rules above.
+`affinity` and `roundrobin` exist so the choice can be re-measured, and are not
+production settings.
+"""
+
+from __future__ import annotations
+
+import collections
+import hashlib
+import itertools
+import json
+import os
+
+UPSTREAMS = [u.strip() for u in os.environ.get(
+    "UPSTREAMS", "http://127.0.0.1:7771,http://127.0.0.1:7772").split(",") if u.strip()]
+ROUTING = os.environ.get("ROUTING", "adaptive").strip().lower()
+# Leading bytes of prompt text that identify a conversation's shared prefix.
+# 4 KiB covers a system prompt plus the start of the first user turn, which is
+# where agent loops keep the text they resend every turn.
+AFFINITY_BYTES = int(os.environ.get("AFFINITY_BYTES", "4096"))
+# Prefixes remembered for pinning. Bounded so a long-lived proxy cannot grow
+# without limit; 4096 conversations is far beyond what this fleet runs at once.
+KNOWN_MAX = int(os.environ.get("KNOWN_MAX", "4096"))
+
+_counter = itertools.count()
+# digest -> replica index, insertion-ordered for O(1) LRU eviction. A prefix is
+# remembered as soon as any request carries it; only a continuation is pinned
+# there, because only a continuation can profit from the cache entry.
+_known: "collections.OrderedDict[bytes, int]" = collections.OrderedDict()
+
+
+def affinity_key(body: bytes, remote: str | None) -> tuple[bytes, bool]:
+    """Key a request by its shared prefix, and report whether it continues one.
+
+    Chat and completions bodies both carry their prompt text in JSON, so the
+    leading bytes of that text are the prefix; a body we cannot parse (or an
+    endpoint with no prompt, e.g. /v1/models) falls back to the client address,
+    which still beats nothing for a single-client loop.
+    """
+    fallback = (remote or "anonymous").encode()
+    try:
+        payload = json.loads(body)
+    except Exception:
+        return fallback, False
+
+    text = ""
+    continuation = False
+    if isinstance(payload, dict):
+        if isinstance(payload.get("prompt"), str):
+            text = payload["prompt"]
+        elif isinstance(payload.get("messages"), list):
+            continuation = len(payload["messages"]) > 1
+            parts = []
+            for msg in payload["messages"]:
+                if isinstance(msg, dict):
+                    content = msg.get("content")
+                    if isinstance(content, str):
+                        parts.append(content)
+                    elif isinstance(content, list):  # multimodal content blocks
+                        parts.extend(
+                            blk.get("text", "") for blk in content
+                            if isinstance(blk, dict) and isinstance(blk.get("text"), str)
+                        )
+            text = "\n".join(parts)
+    if not text:
+        return fallback, continuation
+    return text[:AFFINITY_BYTES].encode("utf-8", "replace"), continuation
+
+
+def pick(key: bytes, continuation: bool, up: list[bool]) -> int:
+    """Replica for a request, or -1 when none is available.
+
+    Down replicas are never selected — a rollout must not send traffic to an
+    engine that is still compiling its graphs — and a pin whose replica is down
+    is re-established on a live one rather than kept pointing at a corpse.
+    """
+    digest = hashlib.sha1(key).digest()
+
+    if ROUTING == "roundrobin":
+        start = next(_counter) % len(UPSTREAMS)
+    elif ROUTING == "adaptive":
+        entry = _known.get(digest)
+        if continuation and entry is not None and up[entry]:
+            _known.move_to_end(digest)
+            return entry
+        # Anything that is not a continuation spreads by counter — including a
+        # batch of requests that happen to share one prefix. Hashing the prefix
+        # would send every member of such a batch to whichever card the hash
+        # names (measured: 29.8 s for a 16-request burst, against 18.6 s when
+        # spread). The counter is only advanced by these requests, so batch
+        # members alternate across the cards.
+        start = next(_counter) % len(UPSTREAMS)
+    else:  # affinity
+        start = int.from_bytes(digest[:8], "big") % len(UPSTREAMS)
+
+    for offset in range(len(UPSTREAMS)):
+        idx = (start + offset) % len(UPSTREAMS)
+        if up[idx]:
+            if ROUTING == "adaptive":
+                _known[digest] = idx
+                _known.move_to_end(digest)
+                if len(_known) > KNOWN_MAX:
+                    _known.popitem(last=False)
+            return idx
+    return -1
+
+
+def route(body: bytes, remote: str | None, up: list[bool]) -> int:
+    """Convenience wrapper: decode the request body and choose a replica."""
+    return pick(*affinity_key(body, remote), up)