diff --git a/doc/reflections/das2rst.das b/doc/reflections/das2rst.das
index 352b06bcca..2282b2f283 100644
--- a/doc/reflections/das2rst.das
+++ b/doc/reflections/das2rst.das
@@ -325,7 +325,7 @@ def document_module_openai(_root : string) {
         group_by_regex("Audio (TTS and STT)", mod, %regex~(speech|speak|transcribe|translate)$%%),
         group_by_regex("Moderations", mod, %regex~(moderations)$%%),
         group_by_regex("Image generation", mod, %regex~(generate_image)$%%),
-        group_by_regex("Vision", mod, %regex~(chat_vision|vision_request_body|image_file_data_uri)$%%)
+        group_by_regex("Vision", mod, %regex~(chat_vision|chat_audio|vision_request_body|audio_request_body|image_file_data_uri|file_base64)$%%)
     )
     documents("OpenAI-compatible API client (chat, embeddings, audio, vision, ...)", mod, "openai.rst", groups)
 }
@@ -343,13 +343,13 @@ def document_module_dasllama(_root : string) {
     var mod = find_module("dasllama")
     var groups <- array<DocGroup>(
         group_by_regex("Model loading and sessions", mod, %regex~(load_model|create_session|create_kv_pool|release_kv_pages|create_batch_workspace|setup_dasllama_jobque|with_dasllama_jobque|caps|mtp_drafter_sidecar|attach_mtp_drafter|mtp_capable)$%%),
-        group_by_regex("Prefix cache", mod, %regex~(create_prefix_cache|prefix_attach|prefix_insert|prefix_checkpoint_at|prefix_release|prefix_held_groups|prefix_chain_list)$%%),
+        group_by_regex("Prefix cache", mod, %regex~(create_prefix_cache|prefix_attach|prefix_insert|prefix_checkpoint_at|prefix_match_len|prefix_release|prefix_held_groups|prefix_chain_list)$%%),
         group_by_regex("Tokenizer", mod, %regex~(encode|decode|piece)$%%),
-        group_by_regex("Evaluation and sampling", mod, %regex~(eval|eval_embd|eval_embd_span|eval_embd_span_mrope|eval_batch|sample|set_seed|stats)$%%),
+        group_by_regex("Evaluation and sampling", mod, %regex~(eval|eval_embd|eval_embd_span|eval_embd_span_mrope|eval_embd_body|media_body_rows|eval_batch|sample|set_seed|stats)$%%),
         group_by_regex("Generation", mod, %regex~(generate|generate_embd)$%%),
         group_by_regex("Embeddings", mod, %regex~(embed)$%%),
         group_by_regex("Vision and audio encoders", mod, %regex~(encode_image|encode_audio)$%%),
-        group_by_regex("Chat", mod, %regex~(create_chat|create_chat_renderer|add_user|add_user_audio|add_user_image|add_user_image_rows|add_user_audio_rows|add_assistant|render_turn|render_turn_marked|render_turn_image|render_turn_audio|render_assistant|render_close|respond|set_thinking)$%%),
+        group_by_regex("Chat", mod, %regex~(create_chat|create_chat_renderer|add_user|add_user_audio|add_user_image|add_user_image_rows|add_user_audio_rows|add_user_span|set_chat_date|add_assistant|render_turn|render_turn_marked|render_turn_image|render_turn_audio|render_assistant|render_close|respond|set_thinking)$%%),
         group_by_regex("Tool calling", mod, %regex~(set_tools|add_tool_results|render_assistant_calls|parse_calls)$%%),
         group_by_regex("Reasoning (thinking models)", mod, %regex~(split_reasoning|make_think_stream|think_feed|think_finish|think_drain|effective_stop_ids|turn_stop_ids|make_nothink_guard|nothink_stop_here)$%%),
         group_by_regex("Operations: prepared images and dispatch", mod, %regex~(dlim_inventory|dlim_clean|set_dispatch_worker_limit|get_dispatch_worker_limit|set_jobque_spin_us|get_jobque_spin_us|set_jobque_spin_gpu_us|get_jobque_spin_gpu_us|get_jobque_spin_in_force|set_single_thread|get_single_thread|select_matmul_backend_for_load|kernel_backend_available)$%%),
@@ -402,7 +402,7 @@ def document_module_dasllama(_root : string) {
         dasllama_type_stanza(f, "struct-dasllama_vision_embedder-VisionState", "VisionState",
             "Caller-owned scratch for the embedder forward of whichever family is carried: the buffers ``encode_image`` reuses across calls. One per embedder user; holds no image state between calls.")
         dasllama_type_stanza(f, "struct-dasllama_audio_embedder-AudioEmbedder", "AudioEmbedder",
-            "A loaded audio encoder of whatever family the mmproj GGUF turned out to be (gemma4a — the gemma-4 E-series Conformer), as produced by ``load_audio_embedder``, which probes the file; ``audio_probe_proj_dim`` answers 0 where absence is an answer. ``audio_proj_dim`` must match the decoder's embedding width. The server's media worker owns one per armed slot.")
+            "A loaded audio encoder of whatever family the mmproj GGUF turned out to be (gemma4a — the gemma-4 E-series Conformer; or a whisper-class tower that ``load_audio_tower`` also serves — qwen2-audio, qwen2.5-omni, ultravox, voxtral), as produced by ``load_audio_embedder``, which probes the file; ``audio_probe_proj_dim`` answers 0 where absence is an answer. ``audio_proj_dim`` must match the decoder's embedding width. The server's media worker owns one per armed slot.")
         dasllama_type_stanza(f, "struct-dasllama_audio_embedder-AudioState", "AudioState",
             "Caller-owned scratch for the audio encoder forward of whichever family is carried: the buffers ``encode_audio`` reuses across calls. One per embedder user; holds no clip state between calls.")
         dasllama_type_stanza(f, "struct-dasllama_image-DlimImageInfo", "DlimImageInfo",
diff --git a/doc/source/reference/tutorials/dasLLAMA_02_chat.rst b/doc/source/reference/tutorials/dasLLAMA_02_chat.rst
index 80bc15f8d4..83ee3022f5 100644
--- a/doc/source/reference/tutorials/dasLLAMA_02_chat.rst
+++ b/doc/source/reference/tutorials/dasLLAMA_02_chat.rst
@@ -116,6 +116,26 @@ memory spent only when the stream actually runs:
    var toks : array<int64>
    render_assistant(m, rchat, "Paris.", toks)   // the exchange, as tokens
 
+A dated system turn
+===================
+
+The Llama-3.1+ template writes two lines into every system turn: the model's
+knowledge cutoff and today's date. Today's date changes the prompt every
+midnight. A test that compares token streams, or a benchmark with a fixed
+prompt, pins the date with ``set_chat_date``; ``""`` gives the clock back:
+
+.. code-block:: das
+
+   set_chat_date("26 Jul 2024")
+   var dated = create_chat_renderer(m, SYSTEM)
+   add_user(dated, "What day is it?")
+   print(decode(m, render_turn(m, dated)))
+   set_chat_date("")
+
+On Llama-3.2-1B-Instruct the system turn then reads
+``Cutting Knowledge Date: December 2023`` and ``Today Date: 26 Jul 2024``.
+A template that states no date - ChatML on SmolLM2, gemma - ignores the pin.
+
 .. seealso::
 
    Full source: :download:`tutorials/dasLLAMA/02_chat.das <../../../../tutorials/dasLLAMA/02_chat.das>`
diff --git a/doc/source/reference/tutorials/dasLLAMA_08_audio_chat.rst b/doc/source/reference/tutorials/dasLLAMA_08_audio_chat.rst
index 563fdf67cf..fed7382042 100644
--- a/doc/source/reference/tutorials/dasLLAMA_08_audio_chat.rst
+++ b/doc/source/reference/tutorials/dasLLAMA_08_audio_chat.rst
@@ -15,9 +15,10 @@ decoder reads inline with text. Supported pairs (decoder + mmproj GGUF):
 Qwen2-Audio, Qwen2.5-Omni (audio side), Ultravox v0.5 (over *stock* Llama-3
 decoders), and Voxtral-Mini. The chat template picks the audio framing
 automatically — the code below is identical for every pair. Qwen3-Omni and
-Gemma-4 E-series audio are served too, but through the ASR surface
-(:ref:`tutorial 07 <tutorial_dasLLAMA_speech_to_text>`'s two-path
-``load_asr_model``), not ``load_audio_tower``.
+Gemma-4 E-series audio are served too, but not by ``load_audio_tower``:
+:ref:`tutorial 07 <tutorial_dasLLAMA_speech_to_text>`'s two-path
+``load_asr_model`` transcribes them, and a Gemma-4 E-series pair chats on this
+page through the ``AudioEmbedder`` carrier rail at the end.
 
 Run::
 
@@ -105,34 +106,84 @@ encoder's rows between them. Unlike an image span, audio rows stay *causal*:
 sound has a left-to-right order.
 
 The rows themselves come from the ``AudioEmbedder`` carrier — the
-family-neutral encoder a scheduler owns. Probe the mmproj with
-``audio_probe_proj_dim`` (0 means no carrier-served audio tower), load it with
-``load_audio_embedder``, and ``encode_audio`` turns 16 kHz PCM into the
-soft-token rows that splice between the two spans — ``encode_image``'s audio
-twin, and exactly what the server's media worker does per clip. The tutorial
-probes the mmproj first: a carrier-served file (the gemma-4 E-series) takes the
-carrier rail — ``section_render_spans`` plus ``section_carrier_encode`` — while
-every ``load_audio_tower`` pair takes the chat rail above.
+family-neutral encoder a scheduler owns. It serves every audio mmproj on this
+page: the ``load_audio_tower`` families and the gemma-4 E-series alike. Probe
+the mmproj with ``audio_probe_proj_dim`` (0 means no audio family serves the
+file), load it with ``load_audio_embedder``, and ``encode_audio`` turns 16 kHz
+PCM into the soft-token rows that splice between the two spans —
+``encode_image``'s audio twin, and exactly what the server's media worker does
+per clip. The tutorial asks a second question first:
+``audio_tower_probe_proj_dim`` answers non-zero for a file ``load_audio_tower``
+serves. Such a pair runs every section, the carrier ones last. A gemma-4
+E-series file answers 0 there, so it runs only the carrier rail —
+``section_render_spans`` plus ``section_carrier_encode``.
 
 The carrier rail closes the loop at the chat layer with the pre-encoded-rows
 seam, ``add_user_image_rows``'s audio twin: ``add_user_audio_rows`` moves the
 encoder's rows onto a *plain* chat — no tower attached — and ``respond`` runs
 the spliced turn, the audio span rendered around the rows. That is how a
-carrier-served family hears in a conversation at all, and the path for a
+gemma-4 E-series pair hears in a conversation at all, and the path for a
 scheduler that owns its own encoder; the rows are ``dim``-wide on every family
-and the call length-checks them:
+and the call length-checks them. ``audio_span_bare(e)`` says whether the span
+takes markers: an ultravox span sits bare in a stock Llama template, which
+knows no audio marker, so pass it as ``bare``:
 
-.. das-doc: given var rows : array<float>; let n = 0l
+.. das-doc: given var rows : array<float>; let n = 0l; var e = AudioEmbedder()
 .. code-block:: das
 
    var chat <- create_chat(m, "", 96l)
-   add_user_audio_rows(m, chat, rows, n)   // moves the rows in
+   add_user_audio_rows(m, chat, rows, n, audio_span_bare(e))   // moves the rows in
    add_user(chat, "What did you hear?")
    respond(m, chat, SamplingParams()) $(piece) {
        print("{piece}")
        return true
    }
 
+The audio in its place: one body by hand
+========================================
+
+So far the audio led the turn. A user message often carries its media in the
+middle: "Here is a recording. <audio> What is being said?". ``add_user_span``
+puts the audio where it sits: ``text_before`` bytes into the turn's text. The
+span carries the media's content key — the same clip gives the same key.
+``render_turn`` then writes ``n_rows`` *media position ids* where the rows go.
+They are negative numbers, which no vocab id uses, so a prefix cache matches
+across the span the same way it matches across text. ``render_turn_audio``
+and ``render_turn_image`` take the same ``text_before`` for the two-span shape.
+
+A program that owns its encoder and scheduler prefills that turn as *one body*
+instead of three evals (text, rows, text). ``media_body_rows`` builds the
+body's rows — the head text, the media rows, the tail text — and
+``eval_embd_body`` prefills them. The span ``(0, 0)`` is empty, so every row
+stays causal, as audio wants; an image passes its non-causal span and its
+grid. On a gemma-4 E-series decoder the body does one more thing: each text
+row's token id rides on the session, so text rows get their own per-layer
+input, and ``eval_embd_body`` spends the ids:
+
+.. das-doc: given let bare = false; let key = 0ul
+.. code-block:: das
+
+   let lead = "Here is a recording. "
+   var rchat <- create_chat_renderer(m, "", 64l)
+   add_user(rchat, "{lead}What is being said?")
+   add_user_span(m, rchat, key, n, length(lead), false, bare)   // audio, not image
+   var turn <- render_turn(m, rchat)
+   var lo = 0l
+   while (!is_media_position(turn[lo])) {
+       lo ++
+   }
+   var head <- [for (k in range64(lo)); turn[k]]
+   var tail <- [for (k in range64(lo + n, long_length(turn))); turn[k]]
+   var s <- create_session(m)
+   var body : array<float>
+   media_body_rows(m, s, head, rows, n, m.config.dim, tail, body)
+   eval_embd_body(m, s, body, long_length(turn), 0l, 0l, int2(0))
+   // sample(s, ...) now answers the turn
+
+On Llama-3.2-1B with the ultravox mmproj and the JFK clip the turn renders as
+``36 text tokens | 187 media ids | 13 text tokens``; on gemma-4 E2B it is
+``17 | 100 | 14``. Both decoders then describe the clip from the one body.
+
 .. seealso::
 
    Full source: :download:`tutorials/dasLLAMA/08_audio_chat.das <../../../../tutorials/dasLLAMA/08_audio_chat.das>`
diff --git a/doc/source/reference/tutorials/dasLLAMA_15_prefix_cache.rst b/doc/source/reference/tutorials/dasLLAMA_15_prefix_cache.rst
index 99374d70d9..7263cf7c6c 100644
--- a/doc/source/reference/tutorials/dasLLAMA_15_prefix_cache.rst
+++ b/doc/source/reference/tutorials/dasLLAMA_15_prefix_cache.rst
@@ -45,6 +45,17 @@ every full page of it. The preview string is only a label for dashboards:
    prefix_insert(cache, pool, s1, p1, "system prompt")
    release_kv_pages(s1)
 
+Before B takes anything, we ask the cache how much of B's prompt it holds.
+``prefix_match_len`` answers with the count ``prefix_attach`` would attach
+right now, and it attaches nothing and touches no entry. A server uses it to
+decide what a request must still bring - the rows of a picture the cache
+already holds need no encode:
+
+.. code-block:: das
+
+   let p2 <- encode(m, "{SYSTEM}{Q2}")
+   print("the cache holds {prefix_match_len(cache, pool, p2)} of B's leading tokens\n")
+
 Stream B starts fresh from the same pool. ``prefix_attach`` walks B's prompt
 against the cached chains: matched pages join B's page table, B's ``n_past``
 jumps past them, and we prefill only the tail. The match is capped one token
@@ -52,7 +63,6 @@ short of the prompt — the model still needs one eval to make logits:
 
 .. code-block:: das
 
-   let p2 <- encode(m, "{SYSTEM}{Q2}")
    var s2 = create_session(m, pool)
    let matched = prefix_attach(cache, pool, s2, p2)
    // eval() only p2[matched..] — the matched pages are already KV
diff --git a/doc/source/reference/utils/dasllama_cli.rst b/doc/source/reference/utils/dasllama_cli.rst
index 5cffce74cb..aeb05cf2f9 100644
--- a/doc/source/reference/utils/dasllama_cli.rst
+++ b/doc/source/reference/utils/dasllama_cli.rst
@@ -344,7 +344,7 @@ where the server's catalog downloads land; ``DASLLAMA_MODELS_DIR`` overrides).
 The ``dasllama-server.toml`` in the current directory, else in
 ``~/.dasllama`` (where the server's control page saves it), else beside the
 program - the server's own lookup - fills whatever the flags leave empty: the model (a ``[[models]]``
-roster's default entry included), its ``image_mmproj``, the ``asr`` and
+roster's default entry included), its ``image_mmproj`` and ``audio_mmproj``, the ``asr`` and
 ``mmproj`` pair, the ``tts`` model and its lane (an ``[[asr]]`` / ``[[tts]]``
 roster's first table), ``gpu`` and the Vulkan detail
 keys, ``threads``, ``ctx``, ``models_dir``. On a box the server's setup page
diff --git a/doc/source/reference/utils/dasllama_server.rst b/doc/source/reference/utils/dasllama_server.rst
index 6ae6b53017..4261e2248c 100644
--- a/doc/source/reference/utils/dasllama_server.rst
+++ b/doc/source/reference/utils/dasllama_server.rst
@@ -167,6 +167,7 @@ Run under ``-jit`` --- the interpreter is refused, it is far too slow for infere
 
    bin/daslang -jit utils/dasllama-server/main.das -- --model <model.gguf> [--port 8080] [--quant q8] \
        [--asr <asr.bin>] [--asr-workers 2] [--mmproj <mmproj.gguf>] [--image-mmproj <mmproj.gguf>] \
+       [--audio-mmproj <mmproj.gguf>] \
        [--ctx 4096] [--streams 4] [--chunk 512] [--chunk-idle 2048] [--page-rows 64] [--prefix N] [--tune]
 
 .. list-table::
@@ -256,7 +257,11 @@ Run under ``-jit`` --- the interpreter is refused, it is far too slow for infere
    * - ``--image-mmproj``
      -
      - ---
-     - Vision mmproj (gemma4uv, gemma4v or gemma3v, sniffed) for the default model --- the chat route then accepts ``image_url`` content parts. When the file also carries a gemma4a audio encoder (the E-series mmproj carries both towers) the same flag arms native audio: ``input_audio`` parts serve through the same slot
+     - Vision mmproj (gemma4uv, gemma4v or gemma3v, sniffed) for the default model --- the chat route then accepts ``image_url`` content parts. When the file also carries an audio encoder (the gemma-4 E-series and the Qwen Omni mmprojs carry both towers) the same flag arms native audio: ``input_audio`` parts serve through the same slot
+   * - ``--audio-mmproj``
+     -
+     - ---
+     - Audio mmproj for the default model --- the chat route then accepts ``input_audio`` content parts: a whisper-class tower with its projector (Qwen2-Audio, Qwen2.5-Omni, Ultravox, Voxtral) or the gemma-4 Conformer. Not needed when ``--image-mmproj`` names a file that carries the audio tower too
    * - ``--ctx``
      -
      - *model*
@@ -394,7 +399,7 @@ model's GPU state lives in VRAM at a time (the tier drops and re-arms on
 switch; ``backend = "cpu"`` slots never evict the GPU owner). Blank keys
 inherit the flat defaults; ``backend`` is ``auto`` | ``cpu`` | ``gpu``, and
 per-entry ``ctx``, ``quant``, ``kv_dtype``, ``streams``, ``chunk``, ``chunk_idle``,
-``page_rows``, ``prefix``, ``mtp``, ``rope_scaling``, ``rope_scale``, ``yarn_orig_ctx`` and ``image_mmproj`` override per model:
+``page_rows``, ``prefix``, ``mtp``, ``rope_scaling``, ``rope_scale``, ``yarn_orig_ctx``, ``image_mmproj`` and ``audio_mmproj`` override per model:
 
 .. code-block:: toml
 
@@ -432,7 +437,7 @@ Setup mode and the model catalog
 ================================
 
 A start with no LLM model at all - no ``--model``, no config, or every
-configured path missing - and no servable ``--tts`` boots into setup mode: the
+configured path missing - and no servable ``--tts`` or ``--asr`` boots into setup mode: the
 port opens, the control page serves, every inference route answers with a
 clean error, and the page leads with the model catalog - a curated, sha-pinned
 list of current models (``model_catalog.das``, a view over the module's one
@@ -452,8 +457,13 @@ wears a fit badge (fits gpu / fits / tight / too big) from the box facts the
 ``/catalog`` document carries; the advertised working set is a hint, not a load
 gate.
 
-``--tts`` alone is a serving start, not a setup start: a speech-only server has
-no LLM slot, so ``/v1/stats`` answers the slotless shape with ``setup`` false.
+``--tts`` or ``--asr`` alone is a serving start, not a setup start: a speech-only
+server has no LLM slot, so ``/v1/stats`` answers the slotless shape with ``setup``
+false and its speech counters live. An ASR model whose decoder is an LLM - a
+two-file model, ``--asr`` with ``--mmproj`` - decodes where the server's LLMs do:
+its worker takes the boot's Metal mode, and ``/v1/stats`` names the outcome under
+``asr.models[]`` as ``decoder`` (``metal`` or ``cpu``). A one-file model (whisper,
+parakeet) decodes on the CPU.
 A ``--tts`` the server cannot serve degrades, it does not die: a missing file
 or a failed load is logged, the speech route is dropped, and the boot serves
 whatever is left - the LLM slots if any loaded, else setup mode.
@@ -545,13 +555,13 @@ Endpoints
      - ``{"model": name}`` --- make ``name`` the default + stepped slot and move the GPU tier to it now (loopback-only; 409 while work is live)
    * - ``POST``
      - ``/v1/models/load``
-     - ``{"path", "id"?, "backend"?, "quant"?, "ctx"?, "image_mmproj"?, "activate"?}`` --- load a GGUF into a new serving slot with no restart (loopback-only; 409 on a live stream set, a taken id, or a GGUF another slot already serves)
+     - ``{"path", "id"?, "backend"?, "quant"?, "ctx"?, "image_mmproj"?, "audio_mmproj"?, "activate"?}`` --- load a GGUF into a new serving slot with no restart (loopback-only; 409 on a live stream set, a taken id, or a GGUF another slot already serves)
    * - ``POST``
      - ``/v1/models/unload``
      - ``{"model": name}`` --- free the slot's weights, KV and VRAM; the default slot refuses (loopback-only)
    * - ``POST``
      - ``/v1/chat/completions``
-     - Chat; ``stream: true`` gives SSE, else a buffered reply. OpenAI function calling (``tools``); ``image_url`` parts under ``--image-mmproj``; ``input_audio`` parts when the mmproj carries the audio tower (one image or one clip per request, on the final user message). A stream sent with ``stream_options: {"include_usage": true}`` ends, before ``[DONE]``, on one chunk with an empty ``choices`` list: ``usage`` (``prompt_tokens``, ``completion_tokens``, ``total_tokens``, and ``prompt_tokens_details.cached_tokens`` --- the prompt tokens the prefix cache attached) and ``timings`` (``ttft_ms``, the scheduler's admit-to-first-token wall, and ``gen_ms``, first token to finish); a stream that does not ask carries no such chunk
+     - Chat; ``stream: true`` gives SSE, else a buffered reply. OpenAI function calling (``tools``); ``image_url`` parts under ``--image-mmproj``; ``input_audio`` parts under ``--audio-mmproj``, or when the image mmproj carries the audio tower (any user message may carry images and clips, up to 16 parts a request, each spliced where the part sits among its message's text parts; a part is encoded and prefilled once --- a continued chat, or the same request again, attaches its span off the prefix cache and never reaches the tower). A stream sent with ``stream_options: {"include_usage": true}`` ends, before ``[DONE]``, on one chunk with an empty ``choices`` list: ``usage`` (``prompt_tokens``, ``completion_tokens``, ``total_tokens``, and ``prompt_tokens_details.cached_tokens`` --- the prompt tokens the prefix cache attached) and ``timings`` (``ttft_ms``, the scheduler's admit-to-first-token wall, and ``gen_ms``, first token to finish); a stream that does not ask carries no such chunk
    * - ``POST``
      - ``/v1/completions``
      - Raw completion; ``stream: true`` gives SSE, else buffered; the same ``stream_options.include_usage`` closing chunk as the chat route
diff --git a/modules/dasHV/dashv/dashv_boost.das b/modules/dasHV/dashv/dashv_boost.das
index 18da726ea9..4ddb1fb750 100644
--- a/modules/dasHV/dashv/dashv_boost.das
+++ b/modules/dasHV/dashv/dashv_boost.das
@@ -255,13 +255,15 @@ def with_http_request(blk : block<(var req : HttpRequest?#) : void>) {
 
 def get_body_bytes(resp : HttpResponse?) : array<uint8> {
     //! Extracts the response body as an ``array<uint8>``.
-    //! Returns an empty array if the response is null, non-OK, or has no content.
+    //! Returns an empty array if the response is null, non-OK, or has no content. The size is the body's own:
+    //! a chunked response carries no ``Content-Length``, and a ``HEAD`` answer carries one with no body.
     var bytes : array<uint8>
-    if (resp == null || resp.status_code != http_status.OK || resp.content_length == 0) return <- bytes
-    bytes |> resize(resp.content_length)
+    let size = resp == null || resp.status_code != http_status.OK ? 0 : length(resp.body)
+    if (size == 0) return <- bytes
+    bytes |> resize(size)
     peek(resp.body) $(bodybytes) {
         unsafe {
-            memcpy(addr(bytes[0]), reinterpret<void?>(bodybytes), resp.content_length)
+            memcpy(addr(bytes[0]), reinterpret<void?>(bodybytes), size)
         }
     }
     return <- bytes
diff --git a/modules/dasLLAMA/.das_module b/modules/dasLLAMA/.das_module
index b694b2d625..efe6cca11b 100644
--- a/modules/dasLLAMA/.das_module
+++ b/modules/dasLLAMA/.das_module
@@ -5,7 +5,7 @@ require daslib/fio
 def initialize(project_path : string) {
     let dasllama_paths = [
         "dasllama_version", "dasllama_env", "dasllama_plane", "dasllama_config", "dasllama_par", "dasllama_boot_restore", "dasllama_parity", "dasllama_tune", "dasllama_tune_scope", "dasllama_kqformat", "dasllama_rope", "dasllama_gpu_tier", "dasllama_kv_dtype", "dasllama_kv_codec", "dasllama_math", "dasllama_math_default", "dasllama_repack", "dasllama_math_aarch64_neon", "dasllama_math_gen", "dasllama_metal_gemm", "dasllama_math_vulkan", "dasllama_math_accelerate", "dasllama_kernel_access", "dasllama_gpu_math", "dasllama_vulkan_dispatch", "dasllama_metal_lens", "dasllama_metal_shapes", "dasllama_metal_common", "dasllama_metal_kernels", "dasllama_metal_prefill", "dasllama_metal_decode", "dasllama_metal_mtp_gemma", "dasllama_gemm_gen", "dasllama_gemm_register", "dasllama_gemm_schema", "dasllama_vulkan_common", "dasllama_vulkan_classes", "dasllama_vulkan_seams", "dasllama_vulkan_decode", "dasllama_vulkan_prefill", "dasllama_vulkan_tower", "dasllama_vulkan_asr_dec", "dasllama_tts_slab", "dasllama_vulkan_tts", "dasllama_convert", "dasllama_gguf",
-        "dasllama_unicode", "dasllama_pretok", "dasllama_tokenizer", "dasllama_spm", "dasllama_bpe", "dasllama_common", "dasllama_layout", "dasllama_gpu_resident", "dasllama_load", "dasllama_ple", "dasllama_sampling", "dasllama_blocks", "dasllama_moe", "dasllama_batch", "dasllama_mtp_gemma", "dasllama_attn_prefill", "dasllama_prefix", "dasllama_asr_types", "dasllama_tower", "dasllama_audio", "dasllama_audio_io", "dasllama_whisper", "dasllama_qwen3a", "dasllama_parakeet", "dasllama_canary", "dasllama_gemma4a", "dasllama_vad", "dasllama_asr", "dasllama_textnorm", "dasllama_postag", "dasllama_g2p", "dasllama_tts_types", "dasllama_tts_blocks", "dasllama_styletts2", "dasllama_kitten", "dasllama_kokoro", "dasllama_pocket", "dasllama_tts", "dasllama_vision", "dasllama_vision_io", "dasllama_gemma4uv", "dasllama_gemma4v", "dasllama_gemma3v", "dasllama_qwen3v", "dasllama_qwen25v", "dasllama_vision_embedder", "dasllama_audio_embedder", "dasllama_metal_tower", "dasllama_metal_asr_dec",
+        "dasllama_unicode", "dasllama_pretok", "dasllama_tokenizer", "dasllama_spm", "dasllama_bpe", "dasllama_common", "dasllama_layout", "dasllama_gpu_resident", "dasllama_load", "dasllama_ple", "dasllama_sampling", "dasllama_blocks", "dasllama_moe", "dasllama_batch", "dasllama_mtp_gemma", "dasllama_attn_prefill", "dasllama_prefix", "dasllama_asr_types", "dasllama_tower", "dasllama_audio", "dasllama_audio_io", "dasllama_whisper", "dasllama_qwen3a", "dasllama_parakeet", "dasllama_canary", "dasllama_gemma4a", "dasllama_vad", "dasllama_asr", "dasllama_textnorm", "dasllama_postag", "dasllama_g2p", "dasllama_tts_types", "dasllama_tts_blocks", "dasllama_styletts2", "dasllama_kitten", "dasllama_kokoro", "dasllama_pocket", "dasllama_tts", "dasllama_vision", "dasllama_vision_io", "dasllama_gemma4uv", "dasllama_gemma4v", "dasllama_gemma3v", "dasllama_qwen3v", "dasllama_qwen25v", "dasllama_vision_embedder", "dasllama_audio_tower", "dasllama_audio_embedder", "dasllama_metal_tower", "dasllama_metal_asr_dec",
         "dasllama_arch_llama", "dasllama_arch_qwen2", "dasllama_arch_qwen3", "dasllama_arch_phi3", "dasllama_arch_gemma2", "dasllama_arch_gemma3", "dasllama_arch_gemma4", "dasllama_arch_qwen2moe", "dasllama_arch_qwen3moe", "dasllama_arch_qwen35", "dasllama_arch_qwen4exp", "dasllama_arch_gptoss", "dasllama_arch_mistral3", "dasllama_arch_glm4moe", "dasllama_image",
         "dasllama_transformer", "dasllama_tools", "dasllama_chat", "dasllama", "dasllama_scheduler", "dasllama_lint", "dasllama_exchange", "dasllama_exchange_schema", "dasllama_fat_start", "dasllama_bench"
     ]
diff --git a/modules/dasLLAMA/ARCHITECTURE_ENGINE_SERVING.md b/modules/dasLLAMA/ARCHITECTURE_ENGINE_SERVING.md
index 81a2159119..d9c2144b40 100644
--- a/modules/dasLLAMA/ARCHITECTURE_ENGINE_SERVING.md
+++ b/modules/dasLLAMA/ARCHITECTURE_ENGINE_SERVING.md
@@ -15,7 +15,21 @@ anchor.
   while none does, since a prefill window's cost is mostly fixed and nothing waits on it; `chunk_defaults` names
   both sizes per serving backend (the chunk 512 where a GPU prefills and 64 on the CPU, whose chunk costs its token count, so the stall follows it down; idle 512,
   2048 on Metal, where four windows in one call run within a few percent of the whole prompt's rate); paged serving donates finished streams'
-  KV pages to the prefix cache, device mode parks their regions. Results flow out as `SchedEvent`s - no HTTP here.
+  KV pages to the prefix cache, device mode parks their regions. The paged pool's blobs hold reserved address
+  room for every stream's context plus the cache's retention, up to `KV_POOL_RESERVE_BYTES` (`kv_pool_reserve`):
+  inside it a doubling moves and fills nothing, where a moved blob is a copy of every cached page inside one
+  request's first token. A prompt is one position stream: a media
+  span's rows stand in it as ids of the media's content (`media_position_id`), so the prefix cache matches,
+  attaches and donates across an image or a clip as across text. A span evals as one body, and up to
+  a chunk of the text either side of it rides that body (`prefill_media_body`) - a prefill call's cost is mostly
+  fixed, so a turn's opening, its media and its closing text are one call where three would each pay the floor. On a
+  gemma-4 E-series decoder the body carries each row's token id (`Session.embd_ids`, 0 for a media row): a text row
+  takes its own token's per-layer input and only the media rows the padding token's.
+  A span attaches
+  whole - a hit ending inside one counts as no hit - and a hit past a grid-roped span restores the span's
+  rope advance on the session. A request may leave a span's rows out where it counts on the cache to hold
+  the span (`prefix_match_len` is the probe for that); if the cache has lost it by admission the stream
+  finishes `media_lost` and its caller brings the rows. Results flow out as `SchedEvent`s - no HTTP here.
   `utils/dasllama-server` owns the writers; `tutorials/dasLLAMA/13_serving.das` is the
   teaching consumer; `tests/test_scheduler.das` gates it against `generate()` references.
   The step clears its gather arrays (`batch_rows`, `batch_toks`, `batch_idx`) before it reaps
diff --git a/modules/dasLLAMA/ARCHITECTURE_GPU.md b/modules/dasLLAMA/ARCHITECTURE_GPU.md
index 5496dd4beb..675638837d 100644
--- a/modules/dasLLAMA/ARCHITECTURE_GPU.md
+++ b/modules/dasLLAMA/ARCHITECTURE_GPU.md
@@ -24,7 +24,7 @@ that a question answered for one backend has an obvious address in the other. Th
 | `dasllama_<gpu>_decode`<br>`dasllama_metal_decode`, `dasllama_vulkan_decode` | the resident token-step driver + decode-time arms; on Vulkan, for a hyper-connection MoE (`Config.hyper_conn`), the split token command and the hot pool's device slots, stacks and hit chains (`ARCHITECTURE_GPU_VULKAN_HC.md#hc-token-command`, `#hc-hot-pool`) | kernel bodies |
 | `dasllama_<gpu>_prefill`<br>`dasllama_metal_prefill`, `dasllama_vulkan_prefill` | the batched prefill driver + batch arms; on Vulkan, for a hyper-connection MoE, the window chain cut after each router (`ARCHITECTURE_GPU_VULKAN_HC.md#hc-window-chain`) | kernel bodies |
 | `dasllama_<gpu>_shapes`<br>`dasllama_metal_shapes` | PORTABLE servability gates - no GPU C++ require, so any box can bake | device calls |
-| the tower driver<br>`dasllama_metal_tower`, `dasllama_vulkan_tower` (the vision ViT chains over the q8 image, qwen25v's over the halfword twin, and the audio chains over the q8 image - the whisper-class towers with their conv stem, the gemma4a Conformer with its chunk front and projector tail, the canary FastConformer with its front, the qwen3a front and mel; on a build without das_metal it fills the gemma4v and gemma3v hook slots, the blocks-only seats `register_qwen3v_gpu_blocks` and `register_qwen25v_gpu_blocks`, the Vulkan seats of those two families, and the audio seats `register_tower_blocks_gpu`, `register_tower_blocks_ln_post_gpu`, `register_tower_conv_gpu`, `register_qwen3a_front_gpu`, `register_qwen3a_mel_gpu`, `register_gemma4a_gpu`, `register_gemma4a_chunk_gpu`, `register_canary_gpu` and `register_canary_front_gpu`; parakeet's seat is Metal's) | one-shot embedder/encoder encodes (gemma4uv chain, the gemma4v ViT, gemma3v SigLIP and qwen3v block loops - qwen3v adds the vision NEOX rope, the fused-qkv weight-offset GEMMs, and the inline deepstack tap + tail merger chains - the whisper-class block loop, the qwen25v window ViT, the gemma4a Conformer chain with its mel/conv front, the FastConformer chain canary and parakeet share - one block body over `CanaryLayerOffs`, parakeet's offsets mapped onto it with no GEMM biases and the tap-major depthwise stamp - the Pocket TTS codec and frame loop (`ARCHITECTURE_GPU_TOWER.md#tower-pocket-codec`, `ARCHITECTURE_GPU_TOWER.md#tower-pocket-frames`) - the whole StyleTTS2 synthesis (kitten and kokoro on both weight lanes: seven seats from PL-BERT to the inverse STFT, the front end on the f32-exact GEMM stamp, the source chain the CPU's operation for operation, `ARCHITECTURE_GPU_TOWER.md#tower-tts-chain`) - the conv frontends + the qwen3a padded-weight slab and GPU front/mel) - no session, no mirror - the Pocket frame loop's per-voice device K/V slot is the one state kept across calls; registers the gemma4uv, gemma4v, gemma3v, qwen3v, qwen25v, encoder_blocks, tower-conv, qwen3a-front, qwen3a-mel, gemma4a, gemma4a-chunk, canary, parakeet (`register_parakeet_gpu` for the blocks, `register_parakeet_gpu_encode` for the whole encode with the subsample front) and StyleTTS2 (`register_styletts2_gpu`, the seven-seat record) and Pocket (`register_pocket_gpu`, the codec and frames seats, `ARCHITECTURE_GPU_TOWER.md#tower-pocket-codec` and `ARCHITECTURE_GPU_TOWER.md#tower-pocket-frames`) hooks; the FastConformer chain borrows `enc_fc_pack` / `enc_fc_softmax` / `enc_fc_unpack` around `enc_f32_mm`, `enc_cn_dw` / `enc_pk_dw`, the prefill's `pf_enc_fc_attn_dev` (every head's attention at once on the device pair, under its crown) and `enc_bias_relu_rows` with the parakeet front's `enc_pk_conv0` / `enc_pk_dw2d` / `enc_pk_xf`, and the `enc_st2_*` row, LSTM, attention and source kernels around `enc_st2_conv_mm` / `enc_st2_conv_exact_mm`, the `enc_pk_*` row, add-and-norm, attention-row and prologue/epilogue GEMV kernels for the Pocket codec and frame loop beside the decode rail's `enc_gemv` / `enc_rpst32_c` and the prefill's `enc_rope`; on Vulkan the whisper-class encoder-output handoff - the served post-norm chain's `xb` plane, kept for the encode in flight alone, which the ASR-decoder driver's cross-KV chain reads (`vulkan_tower_enc_out`) - is the second state kept across calls beside the Pocket slot | LLM or ASR decoder session state |
+| the tower driver<br>`dasllama_metal_tower`, `dasllama_vulkan_tower` (the vision ViT chains over the q8 image, qwen25v's over the halfword twin, and the audio chains over the q8 image - the whisper-class towers with their conv stem, the gemma4a Conformer with its chunk front and projector tail, the canary FastConformer with its front, the qwen3a front and the whisper mel seat; on a build without das_metal it fills the gemma4v and gemma3v hook slots, the blocks-only seats `register_qwen3v_gpu_blocks` and `register_qwen25v_gpu_blocks`, the Vulkan seats of those two families, and the audio seats `register_tower_blocks_gpu`, `register_tower_blocks_ln_post_gpu`, `register_tower_conv_gpu`, `register_qwen3a_front_gpu`, `register_whisper_mel_gpu`, `register_gemma4a_gpu`, `register_gemma4a_chunk_gpu`, `register_canary_gpu` and `register_canary_front_gpu`; parakeet's seat is Metal's) | one-shot embedder/encoder encodes (gemma4uv chain, the gemma4v ViT with its patch-conv stem and projector tail, gemma3v SigLIP with its patch conv and projector tail, and qwen3v block loops - qwen3v adds the vision NEOX rope, the fused-qkv weight-offset GEMMs, and the inline deepstack tap + tail merger chains - the whisper-class block loop with its post-norm or its projector tail behind it, the qwen25v window ViT, the gemma4a Conformer chain with its mel/conv front, the FastConformer chain canary and parakeet share - one block body over `CanaryLayerOffs`, parakeet's offsets mapped onto it with no GEMM biases and the tap-major depthwise stamp - the Pocket TTS codec and frame loop (`ARCHITECTURE_GPU_TOWER.md#tower-pocket-codec`, `ARCHITECTURE_GPU_TOWER.md#tower-pocket-frames`) - the whole StyleTTS2 synthesis (kitten and kokoro on both weight lanes: seven seats from PL-BERT to the inverse STFT, the front end on the f32-exact GEMM stamp, the source chain the CPU's operation for operation, `ARCHITECTURE_GPU_TOWER.md#tower-tts-chain`) - the conv frontends + the qwen3a padded-weight slab and GPU front/mel) - no session, no mirror - the Pocket frame loop's per-voice device K/V slot is the one state kept across calls; registers the gemma4uv, gemma4v (`register_gemma4v_gpu` with its `stem` flag set: the chain takes the stem's columns and runs the patch conv and the position adds itself), gemma3v, qwen3v, qwen25v, whisper-class blocks (`register_tower_blocks_gpu`, `register_tower_blocks_ln_post_gpu` with the post-norm behind them, `register_tower_blocks_tail_gpu` with the projector tail behind them), tower-conv, qwen3a-front, whisper-mel (`register_whisper_mel_gpu`, the spectrum of the qwen3a mel and of the chat towers' chunked mel), gemma4a, gemma4a-chunk, canary (`register_canary_gpu` for the blocks, `register_canary_front_gpu` for the front), parakeet (`register_parakeet_gpu` for the blocks, `register_parakeet_gpu_encode` for the whole encode with the subsample front) and StyleTTS2 (`register_styletts2_gpu`, the seven-seat record) and Pocket (`register_pocket_gpu`, the codec and frames seats, `ARCHITECTURE_GPU_TOWER.md#tower-pocket-codec` and `ARCHITECTURE_GPU_TOWER.md#tower-pocket-frames`) hooks; the whisper-class block GEMMs and its conv stem's second GEMM on a q8 tower borrow `pf_enc_q8_mm`, the projector tails borrow `enc_tw_pool2` and `enc_tw_swiglu_rows` (whisper-class), `enc_tw_pool2d` (gemma4v, gemma3v) and `enc_tw_affine_rows` (gemma4v), the canary front borrows `enc_cn_melnorm`; the FastConformer chain borrows `enc_fc_pack` / `enc_fc_softmax` / `enc_fc_unpack` around `enc_f32_mm`, `enc_cn_dw` / `enc_pk_dw`, the prefill's `pf_enc_fc_attn_dev` (every head's attention at once on the device pair, under its crown) and `enc_bias_relu_rows` with the parakeet front's `enc_pk_conv0` / `enc_pk_dw2d` / `enc_pk_xf`, and the `enc_st2_*` row, LSTM, attention and source kernels around `enc_st2_conv_mm` / `enc_st2_conv_exact_mm`, the `enc_pk_*` row, add-and-norm, attention-row and prologue/epilogue GEMV kernels for the Pocket codec and frame loop beside the decode rail's `enc_gemv` / `enc_rpst32_c` and the prefill's `enc_rope`; on Vulkan the whisper-class encoder-output handoff - the served post-norm chain's `xb` plane, kept for the encode in flight alone, which the ASR-decoder driver's cross-KV chain reads (`vulkan_tower_enc_out`) - is the second state kept across calls beside the Pocket slot | LLM or ASR decoder session state |
 | the ASR-decoder driver<br>`dasllama_metal_asr_dec`, `dasllama_vulkan_asr_dec` | the whisper decoder on the GPU: Metal's 34B weight blob or Vulkan's row-major q8 gather, the f16 resident cross/self K/V, window-granular cross-KV + decode-step serves; registers the whisper cross-KV and decode hooks (`register_whisper_cross_kv_gpu`, `register_whisper_decode_gpu`; family registries in `dasllama_whisper`); on a build without das_metal the Vulkan driver fills them (`ARCHITECTURE_GPU_TOWER_VULKAN.md#vk-asr-decoder`) | kernel bodies, LLM session state |
 | the TTS driver<br>`dasllama_vulkan_tts` (Vulkan; the Metal tower driver's own row carries the TTS seats on an Apple build) | the StyleTTS2 synthesis seats and the Pocket codec and frames seats on the tower's knob - the f32 weight slabs the shared host writer (`dasllama_tts_slab`) lays out, the front end on the f32-exact tile GEMM, the seats registered through `register_styletts2_gpu` and `register_pocket_gpu` on a build without das_metal; the seats serve only while the tier's want arms the device (`DASLLAMA_GPU=1`, off by default), so a run with no flags and no environment overrides synthesizes on the CPU chain on a Vulkan build, where on an Apple build the Metal tower driver's TTS seats serve by default (`DASLLAMA_METAL_TOWER` on) | kernel bodies, the CPU chain's arithmetic (the CPU chain is the specification), LLM or ASR session state |
 | the assistant-drafter driver<br>`dasllama_metal_mtp_gemma` | the gemma-4 assistant drafter on Metal: the sidecar blob upload, the Q-only layer chain reading the TARGET mirror at the two capture layers with the decode's own attention kernels, the speculative round over the batch driver's same-slab verify; registers the `metal` round override and delegates head-less-drafter-less models to `metal_mtp_spec_round` | kernel bodies, mirror ownership |
diff --git a/modules/dasLLAMA/ARCHITECTURE_GPU_ASYMMETRIES.md b/modules/dasLLAMA/ARCHITECTURE_GPU_ASYMMETRIES.md
index d2a176d6cc..adaa03a85c 100644
--- a/modules/dasLLAMA/ARCHITECTURE_GPU_ASYMMETRIES.md
+++ b/modules/dasLLAMA/ARCHITECTURE_GPU_ASYMMETRIES.md
@@ -10,6 +10,8 @@ asymmetries a stamp family ledgers - stays in `ARCHITECTURE_GPU.md#gpu-backends`
 **This list is closed; a new asymmetry lands with its entry here:**
 
 - **The whisper-class block-hook pin is Vulkan-only** (`set_vulkan_audio_blocks`: the block hooks pinned off while the conv stem still serves, the stem-flush and lifetime cells' seat; the Metal tower serves stem and blocks as one chain, nothing to pin apart).
+- **The projector-tail lever and its counter are Metal-only** (`set_metal_tower_tail` / `metal_tower_tail_knob`, `metal_tower_tail_encodes`): the Metal tower runs the whisper-class, gemma3v and gemma4v projector tails behind the blocks in one command buffer, the lever off hands the blocks' rows to the CPU tail for an A/B, and the counter rises once an encode whose tail ran on the device. The Vulkan tower registers no tail seat and runs only gemma4a's tail, inside its own chain, so it has no tail form to pick or count. The callers outside the backend are the tail cells `test_encoder_tail_gpu` (`tests/test_audio.das`) and `test_gemma3v_tail_gpu` (`tests/test_gemma3v.das`).
+- **`metal_tower_mel_encodes` is Metal's mel counter, a function of its own**: it rises once a mel the device mel seat served (`register_whisper_mel_gpu`), the qwen3a mel and the chat towers' chunked mel alike. Vulkan counts the same seat as the `mels` field of `vulkan_tower_stats()`, where Metal's `metal_tower_stats()` carries no mel field. The caller outside the backend is `test_log_mel_chunks_gpu` (`tests/test_audio.das`).
 - **The streaming lane mint and the trimmed lane are Vulkan-only** (`vulkan_mint_begin` / `vulkan_mint_end`, the lever
   `set_vulkan_trim` / `vulkan_trim` with its `restore_vulkan_trim` form): the Vulkan lane carries a device twin the GPU
   walk collects, so its mint streams the walk's entries into the save and a trim can drop the planar families the arena
diff --git a/modules/dasLLAMA/ARCHITECTURE_GPU_TOWER.md b/modules/dasLLAMA/ARCHITECTURE_GPU_TOWER.md
index bee310d2d2..95371f2fb7 100644
--- a/modules/dasLLAMA/ARCHITECTURE_GPU_TOWER.md
+++ b/modules/dasLLAMA/ARCHITECTURE_GPU_TOWER.md
@@ -52,6 +52,56 @@ best-effort: it answers false (or -1) on any shape, knob, quant-mode or device d
 CPU chain serves that encode. Engage is read from counter deltas (`metal_tower_stats`,
 `metal_tower_f16_encodes`), never from "the model ran".
 
+The whisper-class chain serves both weight lanes. An f32 tower's block GEMMs read the f32 blob or
+its halfword twin. A q8 tower's read the q8 planes themselves: `tw_q8_attach` uploads the stem's
+second conv and each block's six GEMM regions once a tower, out of the CPU backend's repack layout
+into the 34-byte q8 blocks the prefill driver's q8 GEMM reads (`q8_region_to_metal_blob`, the
+transform the ASR-decoder driver uploads its planes through), and every site runs on the prefill
+ladder (`pf_enc_q8_mm`) with the activations converted to one half panel where that ladder reads
+one. The device blob is 34/32 of the q8 planes and no image carries it; it drops with the weights
+epoch and the tower shutdown. The stem's first conv reads the f32 blob on both lanes - its
+3 x n_mel columns are not quantized - and where those columns are off the GEMM's 32 lattice (80
+mels: 240) it reads a device copy of its rows zero-padded to the lattice (`tw_conv1_pad_attach`),
+the im2col pass padding its own rows with zeros to the same width.
+
+The whisper-class chain has three forms over one block loop (`TwForm`): the blocks alone, the
+blocks with the tower's post-norm (whisper's encoder output), and the blocks with the projector
+tail - the chat towers' soft tokens (`tw_tail_body`). The tail is the CPU tail's steps at its
+widths, by projector kind: qwen2a pools row pairs (`MetalTwPool2`), norms, and runs one biased
+linear; voxtral pools, norms, and runs the stacked rows through a GELU MLP; ultravox norms every
+position, rms-norms the stacked rows at the projector's own eps, and runs the gated MLP
+(`MetalTwSwigluRows`: silu of a row's second half times its first). A stack is no kernel: the
+stacked row is the same memory read at the wider row. The tail's GEMMs read the f32 blob on the
+f32 tile, so the tail seat serves it on an f32 tower whose widths sit on that tile's lattice
+(`tw_tail_shape_ok`) and serves the blocks alone otherwise - a q8 tower's projector planes are not
+on the device - answering which it served (`TowerTailServed`), so the CPU tail runs exactly when
+the device one did not. Its engage counter is `metal_tower_tail_encodes`, its lever
+`set_metal_tower_tail`.
+
+The vision chains run their ends on the device too. The gemma3v chain ends in its tail - the
+post-norm, the grid mean pool (`MetalTwPool2d`), the soft norm and the projection (`g3v_tail_body`).
+The gemma4v chain takes the stem's columns and runs the patch conv and the position adds itself
+(`g4v_stem_body`; the family registers its seat with `stem` set, and a chain registered without it is
+handed the finished residual stream), then ends in its tail: the grid pool, the sqrt(d) scale and the
+standardize in one row pass (`MetalTwAffineRows`), the weightless rms, and the projection between its
+two clamps (`g4v_tail_body`). With the tail on the device the soft tokens alone come back; the block
+rows stay there.
+
+The gemma4a chain ends in the projector tail, in the blocks' command buffer: the out projection
+and its bias at the encoder's own output width (`gemma4a_mid_dim`, the length of the weightless
+norm's ones row), that norm, then the audio embedder to the decoder's width (`proj_dim`). The
+embedder is square on E2B (1536 by 1536) and widens on E4B (1536 to 2560), so the two widths are
+read apart off the file - the out projection's rows, the embedder's rows - and never assumed equal.
+The chain lands the soft tokens in `Gemma4aState.out` and says so (`out_ready`).
+
+Canary's front runs whole on the device ahead of its block seat (`metal_canary_front`, the front
+seat): off the CPU-windowed frames, the DFT as a GEMM over the transposed twiddles, the power
+spectrum, the mel sums, `MetalCnMelNorm` - the log and the per-feature normalization over the valid
+frames, one thread a feature - then the parakeet front's convs and the input projection. The front
+kernels read tap-major taps and canary's file keeps them channel-major, so the three conv panels
+ride a device copy (`tw_cn_front_attach`); and a stage's valid rows are its conv's image height, so
+a row past them reads as the zero the CPU chain masks it to and no mask pass is dispatched.
+
 The FastConformer chain (canary and parakeet share it: one context, one block body over the
 canary offsets record, parakeet's offsets mapped onto it with no GEMM biases and its tap-major
 depthwise stamp) runs the rel-pos (Transformer-XL) attention one head at a time on the f32 GEMM
diff --git a/modules/dasLLAMA/ARCHITECTURE_MEASUREMENT_SERVED.md b/modules/dasLLAMA/ARCHITECTURE_MEASUREMENT_SERVED.md
index 5a3bbe910b..7029602c40 100644
--- a/modules/dasLLAMA/ARCHITECTURE_MEASUREMENT_SERVED.md
+++ b/modules/dasLLAMA/ARCHITECTURE_MEASUREMENT_SERVED.md
@@ -33,17 +33,24 @@ cached token count differs between reps.
 
 Its speech rows time a whole transcription request - the clip uploaded as a multipart form to
 `/v1/audio/transcriptions` - one row a clip, over all reps behind one untimed request, every rep
-reading the same text. A second row a clip is timed while a chat turn decodes at the chat
+reading the same text. Every request uploads a copy of the clip with one sample moved, the sample
+picked off the clock: a server that keeps the prompts it has evaluated answers a clip it has heard
+from that cache - audio rows included - and a transcription service is not sent the same audio
+twice. A clip that is no PCM WAV goes up as it is. A second row a clip is timed while a chat turn decodes at the chat
 endpoint: the reps start at that turn's first reply text, and the row is refused when the turn
 ends before they do or the text differs from the idle row's. Where the speech encoder runs -
 beside the chat model on the GPU or on the CPU team - is the server's launch, not the
 instrument's: each placement is one run.
 
-Its image rows time a question about an image answered in one token, so the wall is the image's
-encode, the prompt's prefill and that token: per rep a question under a system line no server has
-seen, then a second question under the same line, which a server that keeps the image's rows
-answers from its cache. The row carries the prompt tokens the image and the text make, the same
-on every rep or the row is refused; the first question's cv is the one that voids it.
+Its media rows (`--image`, and `--chat-clip` for an audio clip sent as an `input_audio` part) time a
+question about the part answered in one token, the part ahead of the text, so the wall is the
+part's encode, the prompt's prefill and that token: per rep a question under a system line no
+server has seen, then a second question under the same line - asked again, which a server that
+pays for a part once answers from its cache, neither encoding nor prefilling the part a second
+time. The untimed request ahead of a row asks for a whole answer with thinking off and the bench prints it (`says:`),
+so a row is read beside what the model said of the part. A second untimed request under a system line of the reps' shape follows it:
+a rep's line shares its opening with the line of the rep before, and without it the first rep alone prefills that opening. The row carries the prompt tokens the part and the text make, the same on every rep or the
+row is refused; the first question's cv is the one that voids it.
 
 Its synthesis rows time a whole `/v1/audio/speech` request, one row a model: the answer is the
 finished WAV, so the wall is the time to first audio, printed beside the seconds of speech the
@@ -77,6 +84,17 @@ for a transcription row, the reference as `llama-server -m <gguf> --mmproj <mmpr
 `served_bench.das -- --url <server> --no-chat --image <file> --reps 5` and
 `served_bench.das -- --asr-url <server> --clip <wav> --reps 5`.
 
+A transcription row with no chat model behind it launches ours with the ASR model alone:
+`main.das -- --asr <whisper bin>` for a whisper model, `main.das -- --asr <gguf> --mmproj <mmproj>`
+for Qwen3-ASR. The whisper reference is whisper.cpp `6fc7c33`, built on the box, as
+`whisper-server -m <bin> --port <port> --inference-path /v1/audio/transcriptions`, so the
+client's transcription request reaches it at the path it sends. The client is
+`served_bench.das -- --no-chat --asr-url <server> --clip <wav> --reps 5`.
+
+An audio-chat row (a clip asked about as an `input_audio` part) launches ours with the tower's
+projector beside the model, `main.das -- -m <gguf> --audio-mmproj <mmproj> -p 8123 -s 1`, and the
+client as `served_bench.das -- --url <server> --no-chat --chat-clip <wav> --reps 5`.
+
 Its figures are ledger figures - `PERF_LEDGER.md`, tagged `served` - and nothing else. No record
 store, board or ladder takes them, and none of them compares against an `lcpp_bench` row: the
 rig's `pp` and `tg` time the kernels from an empty cache with no scheduler, no HTTP path and no
diff --git a/modules/dasLLAMA/ARCHITECTURE_MEDIA.md b/modules/dasLLAMA/ARCHITECTURE_MEDIA.md
index fd1040a9eb..eb1c1b68fb 100644
--- a/modules/dasLLAMA/ARCHITECTURE_MEDIA.md
+++ b/modules/dasLLAMA/ARCHITECTURE_MEDIA.md
@@ -135,7 +135,13 @@ carriers name, and no TTS family file (`dasllama_kitten`, `dasllama_kokoro`, `da
 - **`dasllama_audio_embedder.das`** - the audio carrier: `AudioEmbedder` / `AudioState`, the
   vision carrier's audio twin - one union through every seam (server media worker, facade
   `encode_audio`, tutorials), the family probed from the mmproj's audio tensor (or a `.dlim`'s
-  baked tag) at load, one-line arms. Outside a family's own file, an audio family type is named
+  baked tag) at load, one-line arms. It carries two kinds: the gemma-4 Conformer, and the
+  whisper-class tower with its projector (`AudioKind.audio_tower`: Qwen2-Audio, Qwen2.5-Omni, Ultravox,
+  Voxtral), whose family file `dasllama_audio_tower.das` wraps `dasllama_audio`'s tower for the carrier
+  and encodes a clip one 30 s mel chunk at a time into its state's `EncoderState`. The
+  projector says how its rows splice: an ultravox span takes no marker (`audio_span_bare`), since
+  the stock decoder it pairs with declares none, and every other kind takes the markers the
+  decoder's chat template declares. Outside a family's own file, an audio family type is named
   only here, in `dasllama_asr.das`'s union field and one-line arms (the ASR rail's own carrier),
   in the GPU family hooks (`dasllama_metal_tower.das`, `dasllama_metal_asr_dec.das`,
   `dasllama_vulkan_tower.das`, `dasllama_vulkan_asr_dec.das` - each fills the family's own seat
@@ -187,14 +193,19 @@ blocks and merger alike - because the Metal tower reads f32 planes or the baked
 A family file owns the hook SLOT for a stage the GPU can serve - a `var private` function pointer
 plus a `register_*` entry - and a tower driver fills it at `[init]`: the Metal driver on a Metal
 build, the Vulkan driver (`dasllama_vulkan_tower.das`) on a build without das_metal, for the
-blocks seats it serves and the front seats it fills (qwen3a's mel and conv front, gemma4a's
+blocks seats it serves and the front seats it fills (the whisper preprocessor's mel
+`register_whisper_mel_gpu`, which Qwen3-ASR's mel and the chat towers' chunked mel both ask;
+qwen3a's conv front, gemma4a's
 whole chunk, canary's front, parakeet's whole encode - the Metal driver's, asked ahead of the CPU
 front with the blocks seat behind a decline - and the whisper-class blocks-with-post-norm seat
 `register_tower_blocks_ln_post_gpu`, which the whisper encode asks ahead of its CPU block loop and
-post-norm - a decline asks no second seat, its driver's blocks seat declining the same way, while a
-driver with no post-norm seat (Metal) serves the blocks at the blocks seat and the CPU norms; the
+post-norm - a decline asks no second seat, its driver's blocks seat declining the same way; both
+tower drivers fill it, the post-norm one more row pass in the blocks' command buffer; the
 seat serves the family whose post-norm follows the blocks with nothing between, whisper, while the
-families that pool before it, and ultravox, keep the CPU post-norm). The direction is forced: the
+families that pool before it, and ultravox, take the blocks-with-tail seat
+`register_tower_blocks_tail_gpu`, which `audio_encode` asks ahead of the blocks and the CPU
+projector tail and which answers what it served - nothing, the blocks, or the blocks and the tail
+(`TowerTailServed`); the Metal driver fills it). The direction is forced: the
 driver requires the family file for its
 types, so the family cannot require the driver back. A box with no driver leaves the slot empty
 and the CPU form runs. A seat taken over a filled slot (a test's stub through
@@ -203,12 +214,13 @@ and serve counters are a `TtsGpuSeats` of `dasllama_tts_types.das`) gives the di
 `unregister` - one level: the record keeps the registration it displaced, not a stack of them - so
 the driver's seats survive the test.
 
-Every hook answers "declined" in its own return - `false` for the block hooks and qwen3a's mel and
+Every hook answers "declined" in its own return - `false` for the block hooks and the whisper mel and qwen3a's
 front hooks, `-1` for the hooks that return a row count (gemma4a's whole chunk, canary's front) -
 so a decline is a fallback, never an outage, and the CPU form stays the reference. A family calls
-its hook on either lane: the Metal driver declines the q8 encoder and the Vulkan driver the exact
-one, each as a counted non-policy `quant_mode` decline, which under the driver's required mode
-panics - a caller that pins a lane pins the one its driver serves. While the stage-diff witness is
+its hook on either lane: the Metal driver declines the q8 encoder of every family but the
+whisper-class tower, whose chain reads both lanes (`ARCHITECTURE_GPU_TOWER.md#tower-encode-chains`),
+and the Vulkan driver the exact one, each as a counted non-policy `quant_mode` decline, which under
+the driver's required mode panics - a caller that pins a lane pins the one its driver serves. While the stage-diff witness is
 armed (`set_audio_encode_ref_dir`), the whisper-class tower skips its conv and block hooks and runs
 the CPU forms: the witness diffs the CPU stages' rows against reference dumps, and a stage the
 device served leaves nothing to diff.
@@ -227,8 +239,9 @@ column buffer (`s.x0`, `st.xw`) and never the residual stream the CPU half would
 
 A tower serves its GEMMs on one of two lanes: q8 planes (the CPU serving format) or the file's
 exact f32 planes. Un-pinned, the lane follows the fastest GEMM path on the box - a serving Metal
-driver reads the f32 blob and declines q8, so `*_gpu_serves` answering true flips the default to
-exact, and every other box takes q8. Each family exposes the same trio over one `GemmLane` pin
+driver that reads the f32 blob and declines q8 makes `*_gpu_serves` answering true flip the default
+to exact, and every other box takes q8. Whisper carries no lane policy and serves q8 everywhere:
+the Metal tower reads its q8 planes. Each family exposes the same trio over one `GemmLane` pin
 (`lane_serves_q8`, `dasllama_common.das`): `set_*_q8` pins a lane, `reset_*_q8` returns to the
 policy, `*_serves_q8` reports the lane the next load would take. The
 lane picks the image tag, so the two lanes are separate images that coexist.
diff --git a/modules/dasLLAMA/ENVIRONMENT.md b/modules/dasLLAMA/ENVIRONMENT.md
index 50287e8793..30eb89bd5e 100644
--- a/modules/dasLLAMA/ENVIRONMENT.md
+++ b/modules/dasLLAMA/ENVIRONMENT.md
@@ -90,7 +90,7 @@ Apple GPU backend. Absent on non-Apple builds, where setting them does nothing.
 | `DASLLAMA_METAL_TOWER_F16` | flag | on | Serve a tower's weighted GEMMs from a halfword twin of its weights on the crowned tensor mul_mm twins: the image's baked f16 twin plane where the mint bakes one (only for f16-sourced GEMMs, so it holds the file's own values), and the FastConformer chain's device twin of parakeet's f32 blob. Needs a tensor crown - a box without one, or an image without the plane, keeps the f32 route; 0 pins the f32 GEMM route - the A/B rail. |
 | `DASLLAMA_METAL_TOWER_FLASH` | flag | on | Serve head-72 tower attention at %64 canvases on the lifted flash kernel (no score slab, no rowstat pass, no head restrides - the gemma3v-geometry ViTs); 0 pins the three-pass slab - the A/B rail. |
 | `DASLLAMA_METAL_WDEC` | flag | on | Serve the whisper decoder side (cross-KV; the decode step under wdec_step) on the Metal ASR-decoder driver; 0 pins the CPU decoder. |
-| `DASLLAMA_METAL_WDEC_STEP` | flag | on | Serve the whisper DECODE STEP on the GPU too (needs wdec). Small decoders (n_text_state under the 1024 floor; set_metal_wdec_step_min_d) keep the CPU rail - the per-dispatch latency floor beats them. |
+| `DASLLAMA_METAL_WDEC_STEP` | flag | on | Serve the whisper DECODE STEP on the GPU too (needs wdec). Small decoders (n_text_state under the 512 floor; set_metal_wdec_step_min_d) keep the CPU rail - the per-dispatch latency floor beats them. |
 | `DASLLAMA_METAL_ATTN_D` | flag | on | Fused single-pass decode attention (a head of 64, 96, 128, 256 or 512 on every KV codec; sliding windows, attention sinks, the logit soft cap and a second head class included), on the single row, the speculative verify's rows and the batch; 0 is the A/B rail to the chunked pair. |
 | `DASLLAMA_METAL_ATTN_SINGLE` | number | 64 | Row count below which attention uses the single-chunk kernel; clamped to 128. |
 | `DASLLAMA_METAL_MULMM` | flag | on | The mul_mm prefill GEMM; 0 falls back to the legacy per-op path. |
diff --git a/modules/dasLLAMA/PERF_LEDGER.md b/modules/dasLLAMA/PERF_LEDGER.md
index 1b91b52add..9a834cbdd7 100644
--- a/modules/dasLLAMA/PERF_LEDGER.md
+++ b/modules/dasLLAMA/PERF_LEDGER.md
@@ -11,6 +11,94 @@ what it costs today and what the fix would change.
 
 ## Entries
 
+- **MEASURED (2026-10-04, `direction-grade`) - a served media turn's first token, and the speech rows beside
+  mlx-audio.** M5 Max, Metal, `dasllama-server` with one model (`main.das -- -m <gguf> --image-mmproj <mmproj>` or
+  `--audio-mmproj <mmproj>`, `-s 1 --ctx 16384`), the pinned llama-server as `-m <gguf> --mmproj <mmproj> -ngl 99
+  -np 1 -c 16384`, `harness/served_bench.das --url <server> --no-chat --reps 5 --image <jpg> --chat-clip <wav>`
+  (tagged `served`, `out-of-process`), a 60 s rest before each life; the tune sidecar predates the binary. The
+  first token of a question about a 640x480 image or an 8 s clip under a system line no server has seen, ms,
+  ours / the reference; a row over 3% cv is marked void.
+  - The paged KV pool grew by doubling, and a doubling copied and zero-filled every cached page inside one
+    request: Qwen3-VL 4B's image row read cv 7.9% with prefills of 116 ms beside ones of 158, 189 and 271. With
+    the pool's address room reserved at scheduler creation, twenty prefills in a row read 116-118 ms and the
+    row cv 0.9-1.2% over three runs. A model whose K/V passes the 4 GiB reserve (Qwen2-Audio, 524 KB a
+    position) still pays one copy a server life: 246 ms, once.
+  - A media prompt prefilled as three calls - text, rows, text - and each short call paid the call's floor
+    (about 20 ms): Voxtral Mini's clip read 214.7 with 102 of encode and 84 of prefill (21 + 41 + 20). As one
+    call it reads 181.0; Qwen3-VL 4B's image 185 to 148; gemma-4 E2B's image 115 to 82 and E4B's 164 to 98,
+    once the body carries each row's token id.
+  - Images: gemma-4 E2B 81.7 / 141.4, E4B 98.3 / 206.9, 12B 164.3 / 371.2; gemma-3 4B 426.6 / 466.8, 12B
+    561.0 / 666.1; Qwen3-VL 4B 147.2 / 196.5 (the reference void, 3.2%), 8B 220.8 / 295.5; Qwen2.5-Omni 3B
+    188.8 (void, 3.8%) / 224.6, 7B 257.0 (void, 5.7%) / 349.3.
+  - Clips: gemma-4 E2B 77.9 / 125.8 (the reference void, 6.3%), E4B 107.4 / 187.2; Qwen2.5-Omni 3B
+    219.3 / 294.5, 7B 348.2 / 465.6; Ultravox 1B 132.0 / 147.9 (the reference void, 6.1%), 8B 219.1 / 292.3;
+    Voxtral Mini 181.6 / 189.1 (the reference void, 5.3%), Small 439.6 / 503.6 (the reference void, 4.2%);
+    Qwen2-Audio 465.0 / 508.2. The E-series rows and the 12B image are single re-runs after their change; the
+    rest are one sweep taken before the instrument's lead-in request, which is what voids the two Omni images.
+  - Asked again under the same line, both servers answer off their cache within a few ms of each other on
+    every row; the one row the reference leads is Voxtral Small, 167.8 / 161.8.
+  - Speech, `main.das -- --tts <gguf>` against `mlx_audio.server` (mlx-audio 0.5.7), `served_bench.das
+    --no-chat --tts-url <server> --reps 8`, one sentence: ms a request / s of speech / real-time factor.
+    Kokoro-82M (the same voice, ours q8, theirs bf16): 73.1 / 5.50 / 0.013 against 108.9 / 5.47 / 0.020; three
+    sentences 218.9 / 17.5 / 0.013 against 323.5 / 17.1 / 0.019. Kitten nano 22.5 / 5.24 / 0.004 against
+    75.1 / 7.93 / 0.009 and mini 64.6 / 5.84 / 0.011 against 242.7 / 7.55 / 0.032 - their files are the 0.8
+    release and speak the sentence longer, so the factor is the comparison. Pocket (ours the English 2026-04
+    file at q8 and kq, theirs Kyutai's without-voice-cloning weights at full and 8 bit): 67.7 / 4.64 / 0.015
+    and 61.7 / 4.80 / 0.013 against 200.3 / 4.96 / 0.040 (void, 8.6%) and 152.6 / 5.12 / 0.030 (void, 6.7%).
+  - The M5 and M4 boards' Metal rows this arc re-routes are withdrawn until a mint on a fresh sidecar: the
+    ASR rows of whisper tiny and large-v3-turbo, Canary-Qwen, Qwen3-ASR 0.6B, Qwen3-Omni 30B and gemma-4 E2B,
+    and the image rows of gemma-4 E2B and E4B.
+
+- **MEASURED (2026-10-04, `direction-grade`) - canary's mel and subsample front run on the Metal tower.**
+  M5 Max, Metal, canary-qwen-2.5b (the q8_0 decoder, the f32 encoder), in process as the server's
+  ASR worker runs it (the engine's stage clock, the fourth transcription of a clip), the tune sidecar
+  predating the binary. The front seat was filled by the Vulkan driver alone, so on Metal the mel
+  (a twiddle GEMM on the CPU) and the subsample stack ran on the CPU beside 80 ms of blocks on the
+  device.
+  - A 64 s clip: 1274 ms before - mel 239, front 258, blocks 80, projection 7, prefill 56, decode
+    629 - and 772 after, the mel and the front together 8.0. An 8 s clip: 163 ms before, 106 after
+    (3.5 for the two).
+  - The device rows sit 2.1e-3 rel-l2 from the CPU chain's on the jfk clip (3.1e-4 with the CPU
+    front ahead of the device blocks); the transcripts are equal. The reading is `test_model_image.das`'s
+    canary `mtower` arm (`canary mtower encode rel-l2`).
+
+- **MEASURED (2026-10-03, `direction-grade`) - the Metal tower reads a whisper encoder's q8 planes.**
+  M5 Max, Metal, whisper large-v3-turbo, `dasllama-server` with the ASR model alone
+  (`main.das -- --asr ggml-large-v3-turbo.bin`), the reference whisper.cpp `6fc7c33` as
+  `whisper-server -m <bin> --inference-path /v1/audio/transcriptions`, `harness/served_bench.das
+  --no-chat --asr-url <server> --clip <wav> --reps 5` (tagged `served`, `out-of-process`), a 60 s
+  rest before each life, every request a clip no server has heard; the tune sidecar predates the
+  binary, so the CPU kernels ran their fallback stamps. Clips of 8 s, 11 s and 64 s (one 30 s
+  window, one, three), ms a transcription.
+  - The tower declined a q8 encoder, and whisper serves q8: the encoder ran on the CPU and read
+    911.7 / 951.4 / 3092.8. The reference reads 131.3 / 147.1 / 601.5 on the f16 file and
+    127.1 / 139.8 / 554.8 on its q8_0 file (0.87 GB).
+  - The block GEMMs off the q8 blob on the plain q8 tile: 240.5 / 253.1 / 876.7. On the prefill
+    ladder: 153.5 / 166.1 / 608.9. With the stem's second conv off the same blob: 137.4 / 149.0 /
+    541.0, on the 1.2 GB q8 image. The f32 encoder lane on the same tower reads 132.3 / 140.0 /
+    517.9 on a 4.3 GB image.
+  - A window's stages on the q8 lane (the encoder's own stage clock, in process): blocks 102.5 ms
+    (94.0 on the f32 lane), the stem 2.2 (15.6 on the CPU), the decode 21.2, the cross K/V 6.4,
+    the mel 1.4.
+
+- **MEASURED (2026-10-03, `direction-grade`) - a served Qwen3-ASR transcription decodes on the device, and a
+  repeated clip measures the other server's prompt cache.** M5 Max, Metal, `dasllama-server` with the
+  ASR model alone (`main.das -- --asr <gguf> --mmproj <mmproj>`), the pinned llama-server as
+  `-m <gguf> --mmproj <mmproj> -ngl 99 -np 1`, `harness/served_bench.das --no-chat --asr-url <server>
+  --clip <wav> --reps 5` (tagged `served`, `out-of-process`), a 60 s rest before each life; the tune
+  sidecar predates the binary, so the CPU kernels ran their fallback stamps.
+  - The ASR worker's context carried no Metal mode, so the decoder - a `Model` session - prefilled
+    and decoded on the CPU: Qwen3-ASR-0.6B Q8_0 read a 4 s clip in 127.5 ms. The worker takes the
+    engine's mode for a two-file model: 50.5 ms. Inside it (the worker's own stage clock): encode
+    10.7 ms, the 75-row prefill 6.7, twelve decode steps 29.0 - 2.4 ms a token, where the reference's
+    own timing line reads 2.65.
+  - The reference keeps the prompts it has evaluated, audio rows included: the same clip sent again
+    costs it one prompt token (`cached_tokens` 79 of 80) and reads 37.4 ms, and a clip one sample
+    off costs the whole prompt. The instrument's rows before this entry repeated one clip and so
+    read that cache; every request now uploads a clip no server has heard.
+  - Unseen clips, ours / the reference, ms a transcription: Qwen3-ASR-0.6B 4 s 50.5 / 60.7, 8 s
+    76.6 / 98.1 (the reference's cv 6.1%, void); Qwen3-ASR-1.7B 4 s 85.5 / 95.1, 8 s 130.8 / 164.4.
+
 - **MEASURED (2026-10-02) - the K/V mirror's block codecs on the whole-model driver
   (`ARCHITECTURE_GPU_VULKAN_ATTN.md#vk-kv-block-codecs`, `set_gpu_kv_dtype` / the server's `--kv-dtype`): a
   q8_0 mirror is 17/32 of the f16 mirror's bytes and tq4 9/32, and on a model whose context was asked whole
diff --git a/modules/dasLLAMA/REVIEW_TOWER.md b/modules/dasLLAMA/REVIEW_TOWER.md
index 67bd74a79b..df8914d9a8 100644
--- a/modules/dasLLAMA/REVIEW_TOWER.md
+++ b/modules/dasLLAMA/REVIEW_TOWER.md
@@ -59,7 +59,8 @@ checklist names covers, is a defect - add a test cell covering it and name it in
 in the same change.** A gate covers a hook when it asserts a counter rising on a leg where that
 hook is the only hook reachable that raises the counter: `vulkan_tower_stats()`'s or
 `metal_tower_stats()`'s `encodes` and `blocks` for a blocks hook, `encodes` for an encode hook,
-`convs` for a front, conv or chunk hook, on Vulkan `mels` for qwen3a's mel hook; on either
+`convs` for a front, conv or chunk hook, for the mel hook `mels` on Vulkan and `metal_tower_mel_encodes()` on
+Metal, for the whisper-class tail hook `metal_tower_tail_encodes()`; on either
 tower, `styletts2_gpu_stats(<seat>)`'s or `pocket_gpu_stats(<seat>)`'s `served` for a TTS seat.
 
 **A diff that adds a tower kernel (a kernel class a tower driver dispatches), widens the rows an
@@ -83,6 +84,14 @@ call site skips when the hook serves.
 **A diff that makes a tower chain compute anything the CPU code its seat's hook replaces does not
 compute changes that CPU code the same way, in the same diff.**
 
+**A diff that adds or changes a family's chain in the Metal tower or in the Metal ASR-decoder
+driver (`dasllama/dasllama_metal_asr_dec.das`) leaves every stage of that family's served chain -
+the mel, the front, the blocks, the tail, the cross-KV and the decode step - on the device, for
+every model and every weight lane the family serves: a stage that runs on the CPU, and a decline
+other than the knob's, the device's or a failed command buffer's, is a defect - moved to the
+device in the same change, or filed in `followup_metal.md` with the stage and the model named.**
+A stage on the CPU behind a Metal chain reads as served and sets the whole chain's rate.
+
 **A diff that changes what a TTS seat's chain computes in a tower driver applies `REVIEW_TTS.md`
 too.**
 
diff --git a/modules/dasLLAMA/THINKING.md b/modules/dasLLAMA/THINKING.md
index 4d02910aec..3cb58b395f 100644
--- a/modules/dasLLAMA/THINKING.md
+++ b/modules/dasLLAMA/THINKING.md
@@ -29,8 +29,10 @@ family-blind.
 3. **`think_gate` + `assistant_open_think`** (off -> thinking, gemma-4-shaped): the gate
    (`<|think|>`) opens the system turn - rendered even when no system prompt is set - and the
    generation prompt switches to the bare `assistant_open_think` header so the model emits its
-   own thought channel. gemma-4's default `assistant_open` keeps the closed empty
-   `<|channel>thought\n<channel|>` prefill, so thinking-off renders the exact pre-arc tokens.
+   own thought channel. gemma-4's thinking-off `assistant_open` is read off the model's own
+   template: the larger models' template closes an empty `<|channel>thought\n<channel|>` after the
+   model turn's opener, the E-series' opens the turn bare - with the closed thought ahead of it an
+   E-series model writes its reasoning as the answer.
 4. **`stop_nothink`** - guarded stop tokens in force whenever the next turn is NOT a thinking
    turn. gemma-4 lists its channel markers: an instruct-mode E-series model rambles past its
    answer through a stray `<channel|>` (`...4.<channel|>4`), and the same model opens a media
diff --git a/modules/dasLLAMA/dasllama/dasllama.das b/modules/dasLLAMA/dasllama/dasllama.das
index 906d8ee108..7ff669e9b0 100644
--- a/modules/dasLLAMA/dasllama/dasllama.das
+++ b/modules/dasLLAMA/dasllama/dasllama.das
@@ -117,6 +117,12 @@ def prefix_checkpoint_at(cache : PrefixCache; pool : KVPool; session : Session;
     return prefix_checkpoint_at_(cache, pool, session, prompt, matched, stable_at)
 }
 
+def prefix_match_len(cache : PrefixCache; pool : KVPool; prompt : array<int64>) : int64 {
+    //! How many leading positions of ``prompt`` a ``prefix_attach`` would attach right now, attaching nothing: a probe
+    //! for a caller deciding what a request must bring (a media span's rows). 0 on a recurrent model's cache.
+    return prefix_match_len_(cache, pool, prompt)
+}
+
 def prefix_attach(var cache : PrefixCache; var pool : KVPool; var session : Session; prompt : array<int64>) : int64 {
     //! Attach the longest cached prefix of ``prompt`` to a FRESH paged ``session`` of ``pool``:
     //! matched pages join the session's block table and ``n_past`` advances past them, so the
@@ -181,6 +187,18 @@ def eval_embd(model : Model; var session : Session; embd : array<float>; npos :
     eval_embd_(model, session, embd, npos, non_causal)
 }
 
+def eval_embd_body(model : Model; var session : Session; embd : array<float>; npos, span_lo, span_hi : int64; grid : int2) {
+    //! Prefill ``npos`` rows built by ``media_body_rows``: [span_lo, span_hi) a non-causal span (empty = every row
+    //! causal), roped on a merged image ``grid`` where one is given.
+    eval_embd_body_(model, session, embd, npos, span_lo, span_hi, grid)
+}
+
+def media_body_rows(model : Model; var session : Session; head : array<int64>; rows : array<float>; n_media, src_w : int64;
+                    tail : array<int64>; var embd : array<float>) {
+    //! One prefill body's rows for ``eval_embd_body`` on ``session``: ``head`` text, ``n_media`` media rows of width ``src_w``, ``tail`` text.
+    media_body_rows_(model, session, head, rows, n_media, src_w, tail, embd)
+}
+
 def eval_embd_span(model : Model; var session : Session; embd : array<float>; npos, span_lo, span_hi : int64) {
     //! ``eval_embd`` for a prompt carrying one NON-CAUSAL image span: rows ``[span_lo, span_hi)``
     //! prefill with every query attending the whole span, the text around them causally — the
@@ -321,11 +339,24 @@ def add_user_image_rows(model : Model; var chat : ChatSession; var rows : array<
     add_user_image_rows_(model, chat, rows, n_rows, grid)
 }
 
-def add_user_audio_rows(model : Model; var chat : ChatSession; var rows : array<float>; n_rows : int64) {
-    //! Queue PRE-ENCODED audio soft-token rows (what ``encode_audio`` emits — ``dim``-wide on
-    //! every family, length-checked) for the next ``respond``. MOVES ``rows``; works on a plain
-    //! chat — no tower needed: the carrier-served families (the gemma-4 E-series) hear this way.
-    add_user_audio_rows_(model, chat, rows, n_rows)
+def set_chat_date(date : string) {
+    //! Pin the date a Llama-3.1+ system turn states (``"26 Jul 2024"``); ``""`` returns it to the day the turn
+    //! renders. For a prompt that must not move with the calendar - a pinned test stream, a benchmark.
+    set_chat_date_(date)
+}
+
+def add_user_span(model : Model; var chat : ChatSession; key : uint64; n_rows : int64; text_before : int; is_image : bool; bare : bool = false) {
+    //! Mark the pending user turn as carrying a media span inline: ``render_turn`` and ``render_assistant`` then lay
+    //! ``n_rows`` position ids (``media_position_id`` over the media's content ``key``) where the media sits,
+    //! ``text_before`` bytes into the turn's text. The rows themselves are the caller's to eval at those positions.
+    add_user_span_(model, chat, key, n_rows, text_before, is_image, bare)
+}
+
+def add_user_audio_rows(model : Model; var chat : ChatSession; var rows : array<float>; n_rows : int64; bare : bool = false) {
+    //! Queue PRE-ENCODED audio soft-token rows (what ``encode_audio`` emits — ``dim``-wide, length-checked) for the
+    //! next ``respond``. MOVES ``rows``; works on a plain chat, no tower needed. Pass the encoder's
+    //! ``audio_span_bare`` as ``bare``: an ultravox span takes no marker, so a stock template serves it.
+    add_user_audio_rows_(model, chat, rows, n_rows, bare)
 }
 
 def encode_image(embedder : VisionEmbedder; var scratch : VisionState; img : VisionImage;
@@ -377,18 +408,18 @@ def render_turn_marked(model : Model; chat : ChatSession) : RenderedTurn {
     return <- render_turn_marked_(model, chat)
 }
 
-def render_turn_image(model : Model; chat : ChatSession; var head : array<int64>; var tail : array<int64>) {
-    //! ``render_turn``'s IMAGE twin: the turn's prefill as the two token spans that bracket the
-    //! image soft-token splice — ``head`` before the rows, ``tail`` after. Render-only (no KV, no
-    //! embedder): the rows come from ``encode_image``, and a scheduler prefills head, rows, tail.
-    render_turn_image_(model, chat, head, tail)
+def render_turn_image(model : Model; chat : ChatSession; var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
+    //! ``render_turn``'s IMAGE twin: the two token spans that bracket the image soft-token splice — ``head`` before the
+    //! rows, ``tail`` after. Render-only (no KV, no embedder): the rows come from ``encode_image``.
+    //! ``text_before`` bytes of the user text render ahead of the image (0: the image leads the turn).
+    render_turn_image_(model, chat, head, tail, text_before)
 }
 
-def render_turn_audio(model : Model; chat : ChatSession; var head : array<int64>; var tail : array<int64>) {
+def render_turn_audio(model : Model; chat : ChatSession; var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
     //! ``render_turn``'s AUDIO twin: the same two-span contract around the audio soft-token splice
     //! (the template's audio span markers). Render-only (no KV, no encoder): the rows come from
-    //! ``encode_audio``, and a scheduler prefills head, rows, tail.
-    render_turn_audio_(model, chat, head, tail)
+    //! ``encode_audio``, and a scheduler prefills head, rows, tail. ``text_before`` as in ``render_turn_image``.
+    render_turn_audio_(model, chat, head, tail, text_before)
 }
 
 def render_assistant(model : Model; var chat : ChatSession; text : string; var out : array<int64>) {
diff --git a/modules/dasLLAMA/dasllama/dasllama_audio.das b/modules/dasLLAMA/dasllama/dasllama_audio.das
index fe3e907b4c..c3f086756a 100644
--- a/modules/dasLLAMA/dasllama/dasllama_audio.das
+++ b/modules/dasLLAMA/dasllama/dasllama_audio.das
@@ -198,18 +198,16 @@ def fft_pow2_run(n : int64; rev : int const?; tw : float const?; var reim : floa
 }
 
 //! Whisper log-mel spectrogram over the full padded input, split into full 3000-frame chunks —
-//! the mtmd flavor end-to-end (pad to ≥31 s, reflect-200 head, Hann/hop-160 power spectra,
-//! slaney mel, log10, global max−8 clamp). Audio ≤30 s yields exactly one chunk.
+//! the mtmd flavor end-to-end (reflect-200 head, 30 s of zeros and 200 past the audio, Hann/hop-160
+//! power spectra, slaney mel, log10, global max−8 clamp). Audio under 30 s yields exactly one chunk.
 def log_mel_chunks(samples : array<float> | #; n_mel : int64) : array<MelChunk> {
     let n_in = length(samples)
-    // this flavor zero-extends short input to chunk+1 seconds BEFORE the stage pads — the head
-    // reflect below must read from the extended buffer, not the raw input
-    let min_samples = int(AUDIO_SAMPLE_RATE * 31l)
-    let n_base = max(n_in, min_samples)
+    // the head reflect reads one sample plus half a window: shorter input counts as that many, zero past its end
+    let n_base = max(n_in, int(AUDIO_N_FFT / 2l) + 1)
     let head = int(AUDIO_N_FFT / 2l)                       // reflect pad
     let tail = int(AUDIO_SAMPLE_RATE * 30l) + head         // 30 s zeros + 200
     let n_padded = head + n_base + tail
-    var padded : array<float>
+    var inscope padded : array<float>
     padded |> reserve(n_padded)
     padded |> resize(n_padded)                             // resize zero-fills
     for (i in range(n_in)) {
@@ -222,12 +220,12 @@ def log_mel_chunks(samples : array<float> | #; n_mel : int64) : array<MelChunk>
     let n_fft = AUDIO_N_FFT
     let n_bins = n_fft / 2l + 1l
     let n_len = (int64(n_padded) - n_fft) / AUDIO_HOP + 1l
-    let hann <- build_hann_window(n_fft)
-    let twiddles <- build_dft_twiddles(n_fft)
-    let filters <- build_mel_filterbank(n_mel, n_fft, AUDIO_SAMPLE_RATE)
+    var inscope hann <- build_hann_window(n_fft)
+    var inscope twiddles <- build_dft_twiddles(n_fft)
+    var inscope filters <- build_mel_filterbank(n_mel, n_fft, AUDIO_SAMPLE_RATE)
 
     // windowed frames [n_len × n_fft]
-    var xw : array<float>
+    var inscope xw : array<float>
     xw |> reserve_resize(int(n_len * n_fft))
     for (i in range64(n_len)) {
         let off = i * AUDIO_HOP
@@ -236,45 +234,22 @@ def log_mel_chunks(samples : array<float> | #; n_mel : int64) : array<MelChunk>
         }
     }
 
-    // DFT as one GEMM: [n_len × n_fft] · [n_fft × 2·n_bins] -> interleaved re/im
-    var reim : array<float>
-    reim |> reserve(int(n_len * n_bins * 2l))
-    reim |> resize(int(n_len * n_bins * 2l))               // gemm accumulates: starts zeroed
-    gemm_f32(unsafe(addr(reim[0])), unsafe(addr(xw[0])), unsafe(addr(twiddles[0])),
-             n_len, n_fft, n_bins * 2l)
-
-    // power spectra -> mel (float products, double sum in bin order), log10
-    let mel_floor = 5.960464477539063e-08lf                // 2^-24, the fixed filterbank floor
-    let log10_e = 0.43429448190325176lf
-    var mel : array<float>
-    mel |> reserve(int(n_mel * n_len))
-    mel |> resize(int(n_mel * n_len))                      // mel-major [n_mel][n_len]
-    var power : array<float>
-    power |> resize(int(n_bins))
-    for (i in range64(n_len)) {
-        for (k in range64(n_bins)) {
-            let re = reim[i * n_bins * 2l + k * 2l]
-            let im = reim[i * n_bins * 2l + k * 2l + 1l]
-            power[k] = re * re + im * im
-        }
-        for (m in range64(n_mel)) {
-            var sum = 0.0lf
-            for (k in range64(n_bins)) {
-                sum += double(power[k] * filters[m * n_bins + k])
-            }
-            mel[m * n_len + i] = float(log(max(sum, mel_floor)) * log10_e)
-        }
+    var inscope wm = WhisperMel(n_mel = n_mel, n_len = n_len, n_len_org = n_len)   // mel-major [n_mel][n_len]
+    wm.data |> reserve(n_mel * n_len)
+    wm.data |> resize(n_mel * n_len)
+    if (!whisper_mel_gpu(xw, n_len, n_fft, n_bins, n_mel, twiddles, filters, wm)) {
+        log_mel_spectrum_cpu(xw, twiddles, filters, n_len, n_fft, n_bins, n_mel, wm.data)
     }
 
     // whisper-style dynamic clamp + scale, GLOBAL over the padded spectrogram; the clamp value
     // round-trips through float before the (x+4)/4 double math - the round-trip is what keeps
     // the mel plane bit-exact against the reference
     var mmax = -1e20lf
-    for (v in mel) {
+    for (v in wm.data) {
         mmax = max(mmax, double(v))
     }
     mmax -= 8.0lf
-    for (v in mel) {
+    for (v in wm.data) {
         let clamped = double(v) < mmax ? float(mmax) : v
         v = float((double(clamped) + 4.0lf) / 4.0lf)
     }
@@ -287,7 +262,7 @@ def log_mel_chunks(samples : array<float> | #; n_mel : int64) : array<MelChunk>
         c.data |> resize(int(n_mel * AUDIO_CHUNK_FRAMES))
         for (m in range64(n_mel)) {
             for (i in range64(AUDIO_CHUNK_FRAMES)) {
-                c.data[m * AUDIO_CHUNK_FRAMES + i] = mel[m * n_len + off + i]
+                c.data[m * AUDIO_CHUNK_FRAMES + i] = wm.data[m * n_len + off + i]
             }
         }
         chunks |> emplace(c)
@@ -296,6 +271,53 @@ def log_mel_chunks(samples : array<float> | #; n_mel : int64) : array<MelChunk>
     return <- chunks
 }
 
+//! The whisper preprocessor's spectrum on the CPU: the DFT as one GEMM over the windowed frames `xw`, the power spectra,
+//! the mel sums in bin order and their log10 into the mel-major `mel` [n_mel][n_len] - what the mel seat serves on a device.
+def private log_mel_spectrum_cpu(xw, twiddles, filters : array<float>; n_len, n_fft, n_bins, n_mel : int64; var mel : array<float>) {
+    // DFT as one GEMM: [n_len × n_fft] · [n_fft × 2·n_bins] -> interleaved re/im
+    var inscope reim : array<float>
+    reim |> reserve(n_len * n_bins * 2l)
+    reim |> resize(n_len * n_bins * 2l)                    // gemm accumulates: starts zeroed
+    gemm_f32(unsafe(addr(reim[0])), unsafe(addr(xw[0])), unsafe(addr(twiddles[0])),
+             n_len, n_fft, n_bins * 2l)
+
+    // power spectra -> mel (float products, double sum in bin order), log10
+    let mel_floor = 5.960464477539063e-08lf                // 2^-24, the fixed filterbank floor
+    let log10_e = 0.43429448190325176lf
+    var inscope power : array<float>
+    power |> resize(n_bins)
+    for (i in range64(n_len)) {
+        for (k in range64(n_bins)) {
+            let re = reim[i * n_bins * 2l + k * 2l]
+            let im = reim[i * n_bins * 2l + k * 2l + 1l]
+            power[k] = re * re + im * im
+        }
+        for (m in range64(n_mel)) {
+            var sum = 0.0lf
+            for (k in range64(n_bins)) {
+                sum += double(power[k] * filters[m * n_bins + k])
+            }
+            mel[m * n_len + i] = float(log(max(sum, mel_floor)) * log10_e)
+        }
+    }
+}
+
+//! the GPU mel hook: DFT, power and log10 mel off the CPU-windowed `xw` frames into `m.data` (mel-major, no clamp)
+typedef WhisperMelGpuFn = function<(xw : array<float>; n_len, n_fft, n_bins, n_mel : int64;
+                                    twiddles, filters : array<float>; var m : WhisperMel) : bool>
+var private g_mel_gpu : WhisperMelGpuFn
+var private g_mel_gpu_set = false
+
+[arch(at="../ARCHITECTURE_MEDIA.md#tower-gpu-hook")]
+def register_whisper_mel_gpu(fn : WhisperMelGpuFn) {
+    g_mel_gpu = fn
+    g_mel_gpu_set = true
+}
+
+//! the mel seat asked: true where a driver landed the log10 mel in `m.data`, false with no seat or on its decline
+def whisper_mel_gpu(xw : array<float>; n_len, n_fft, n_bins, n_mel : int64; twiddles, filters : array<float>; var m : WhisperMel) : bool
+    => g_mel_gpu_set && invoke(g_mel_gpu, xw, n_len, n_fft, n_bins, n_mel, twiddles, filters, m)
+
 //! Full-length whisper-flavor log-mel spectrogram: total frame count (audio + the 30 s
 //! zero tail), the real-audio frame count (``n_len_org`` = the driver's seek_end), and
 //! mel-major ``[n_mel][n_len]`` data.
@@ -1013,10 +1035,12 @@ def load_audio_tower(path : string; q8 : bool = false) : AudioTower {
         let img = image_path_for(path, tag)
         let ts_img = ref_time_ticks()
         var t = AudioTower()
-        if (load_image(img, t, tag)) {
+        // an exact-lane image minted before the half twin rode it carries none: where the file's GEMMs are halves, mint again
+        if (load_image(img, t, tag) && (q8 || length(t.wblob) > 0l || !audio_tower_half_gemms(path))) {
             to_log(LOG_INFO, "dasLLAMA: prepared tower image mapped in {get_time_usec(ts_img) / 1000} ms - {img}\n")
             return <- t
         }
+        delete t
         var inscope st <- stage_audio_tower(path, q8)
         var built = AudioTower()
         if (cache_via_image_staged(st, built, img, tag)) {
@@ -1032,6 +1056,103 @@ def load_audio_tower(path : string; q8 : bool = false) : AudioTower {
     return <- built
 }
 
+//! whether every block GEMM of a whisper-class mmproj - q, k, v, out, the two FFN matrices of each of `n_layer` blocks - is
+//! stored as ggml type `gt`: the half twin is baked only off a file whose GEMMs are all one half type
+def tower_gemm_types_uniform(m : GGUFMeta; n_layer : int64; gt : int) : bool {
+    for (l in range64(n_layer)) {
+        for (nm in ["attn_q", "attn_k", "attn_v", "attn_out", "ffn_up", "ffn_down"]) {
+            if (gguf_tensor_type(m, "a.blk.{l}.{nm}.weight") != gt) {
+                return false
+            }
+        }
+    }
+    return true
+}
+
+//! Whether a whisper-class mmproj stores every block GEMM in one type a halfword holds - f16, bf16, or Q8_0, whose
+//! eight-bit quants times a half scale the device's f32 tile would stage as halves anyway; false for a file that cannot be read
+def private audio_tower_half_gemms(path : string) : bool {
+    let f = fopen(path, "rb")
+    return false if (f == null)
+    var half = false
+    fmap(f) $(var bytes : array<uint8>#) {
+        return if (!gguf_magic_ok(bytes))
+        var inscope m <- parse_gguf_meta(bytes)
+        let gt = gguf_tensor_type(m, "a.blk.0.attn_q.weight")
+        let n_layer = gguf_has(m, "clip.audio.block_count") ? gguf_int(m, bytes, "clip.audio.block_count") : 0l
+        half = (gt == GGML_TYPE_BF16 || gt == GGML_TYPE_F16 || gt == GGML_TYPE_Q8_0) && n_layer > 0l && tower_gemm_types_uniform(m, n_layer, gt)
+    }
+    fclose(f)
+    return half
+}
+
+//! the projector kind an mmproj's `clip.projector_type` names, false for a type the audio tower does not serve
+def private audio_tower_projector(proj : string; var kind : AudioProjKind&) : bool {
+    if (proj == "qwen2a" || proj == "qwen2.5o") {   // omni's audio side is qwen2a verbatim
+        kind = AudioProjKind.qwen2a
+    } elif (proj == "ultravox") {
+        kind = AudioProjKind.ultravox
+    } elif (proj == "voxtral") {
+        kind = AudioProjKind.voxtral
+    } else {
+        return false
+    }
+    return true
+}
+
+//! An MLP projector's hidden and output widths off its tensors - `clip.audio.projection_dim` lies for ultravox-1b (4096
+//! against 2048) - zeros where a tensor is missing
+def private audio_tower_mlp_shape(m : GGUFMeta; kind : AudioProjKind; mm1_in : int64) : tuple<mm1_out : int64; proj_dim : int64> {
+    let i1 = gguf_find_tensor(m, "mm.a.mlp.1.weight")
+    let i2 = gguf_find_tensor(m, "mm.a.mlp.2.weight")
+    return (mm1_out = 0l, proj_dim = 0l) if (i1 < 0 || i2 < 0 || mm1_in <= 0l)
+    let mm1_out = m.tensors[i1].n_elem / mm1_in
+    let mm2_in = kind == AudioProjKind.ultravox ? mm1_out / 2l : mm1_out
+    return (mm1_out = mm1_out, proj_dim = mm2_in > 0l ? m.tensors[i2].n_elem / mm2_in : 0l)
+}
+
+//! What a whisper-class audio mmproj (qwen2a, qwen2.5o, ultravox, voxtral) says of itself, read off its metadata: the
+//! decoder width it projects to and its projector kind. `dim` 0 for a missing file, a file that is no GGUF, or an mmproj
+//! this tower does not serve. Never panics.
+def private audio_tower_probe(path : string) : tuple<dim : int64; kind : AudioProjKind> {
+    var res = (dim = 0l, kind = AudioProjKind.qwen2a)
+    return res if (path |> ends_with(".dlim"))
+    let f = fopen(path, "rb")
+    return res if (f == null)
+    fmap(f) $(var bytes : array<uint8>#) {
+        return if (!gguf_magic_ok(bytes))
+        var inscope m <- parse_gguf_meta(bytes)
+        var kind = AudioProjKind.qwen2a
+        if (!gguf_has(m, "clip.projector_type") || !audio_tower_projector(gguf_str(m, bytes, "clip.projector_type"), kind)
+                || !gguf_has(m, "clip.audio.embedding_length") || gguf_find_tensor(m, "a.position_embd.weight") < 0) {
+            return
+        }
+        res.kind = kind
+        if (kind == AudioProjKind.qwen2a) {
+            res.dim = gguf_has(m, "clip.audio.projection_dim") ? gguf_int(m, bytes, "clip.audio.projection_dim") : 0l
+        } else {
+            let stack = gguf_has(m, "clip.audio.projector.stack_factor") ? gguf_int(m, bytes, "clip.audio.projector.stack_factor") : 1l
+            res.dim = audio_tower_mlp_shape(m, kind, gguf_int(m, bytes, "clip.audio.embedding_length") * stack).proj_dim
+        }
+    }
+    fclose(f)
+    return res
+}
+
+//! The decoder width a whisper-class audio mmproj projects to; 0 where the tower does not serve the file. Never panics:
+//! the seams gate an audio arm on it.
+def audio_tower_probe_proj_dim(path : string) : int64 => audio_tower_probe(path).dim
+
+//! Whether a tower's soft tokens sit in the user turn with no span marker around them: the ultravox projector pairs with
+//! a stock decoder whose template and vocab know no audio marker
+def audio_span_bare(kind : AudioProjKind) : bool => kind == AudioProjKind.ultravox
+
+//! `audio_span_bare` for an mmproj on disk; false where the tower does not serve the file
+def audio_tower_probe_span_bare(path : string) : bool {
+    let p = audio_tower_probe(path)
+    return p.dim > 0l && audio_span_bare(p.kind)
+}
+
 //! Mint a served tower from a staged read WITHOUT touching disk — the off-rail control for suites.
 def mint_audio_tower(var st : AudioTowerStaging; var out : AudioTower; q8 : bool = false) {
     cache_via_image_staged(st, out, "", q8 ? "tower-q8" : "tower-f32")
@@ -1048,13 +1169,7 @@ def stage_audio_tower(path : string; q8 : bool = false) : AudioTowerStaging {
     fmap(f) $(var bytes : array<uint8>#) {
         var inscope m <- parse_gguf_meta(bytes)
         let proj = gguf_str(m, bytes, "clip.projector_type")
-        if (proj == "qwen2a" || proj == "qwen2.5o") {   // omni's audio side is qwen2a verbatim
-            st.e.proj_kind = AudioProjKind.qwen2a
-        } elif (proj == "ultravox") {
-            st.e.proj_kind = AudioProjKind.ultravox
-        } elif (proj == "voxtral") {
-            st.e.proj_kind = AudioProjKind.voxtral
-        } else {
+        if (!audio_tower_projector(proj, st.e.proj_kind)) {
             panic("dasLLAMA: audio tower supports qwen2a/qwen2.5o/ultravox/voxtral projectors, got '{proj}'")
         }
         st.e.n_mel = gguf_int(m, bytes, "clip.audio.num_mel_bins")
@@ -1079,18 +1194,14 @@ def stage_audio_tower(path : string; q8 : bool = false) : AudioTowerStaging {
         }
         st.e.n_ctx = m.tensors[pi].n_elem / d
 
-        // shapes come from the tensors, not clip.audio.projection_dim — it lies for ultravox-1b (4096 vs actual 2048)
-        var mm1_in = 0l
+        let mm1_in = st.e.proj_kind != AudioProjKind.qwen2a ? d * st.e.stack_factor : 0l
         if (st.e.proj_kind != AudioProjKind.qwen2a) {
-            mm1_in = d * st.e.stack_factor
-            let i1 = gguf_find_tensor(m, "mm.a.mlp.1.weight")
-            let i2 = gguf_find_tensor(m, "mm.a.mlp.2.weight")
-            if (i1 < 0 || i2 < 0) {
+            let shape = audio_tower_mlp_shape(m, st.e.proj_kind, mm1_in)
+            if (shape.proj_dim == 0l) {
                 panic("dasLLAMA: mm.a.mlp.1/2.weight missing from '{proj}' mmproj")
             }
-            st.e.mm1_out = m.tensors[i1].n_elem / mm1_in
-            let mm2_in = st.e.proj_kind == AudioProjKind.ultravox ? st.e.mm1_out / 2l : st.e.mm1_out
-            st.e.proj_dim = m.tensors[i2].n_elem / mm2_in
+            st.e.mm1_out = shape.mm1_out
+            st.e.proj_dim = shape.proj_dim
         }
 
         // fixed blob layout: convs, pos, per-layer region, post-ln, projector
@@ -1158,10 +1269,13 @@ def stage_audio_tower(path : string; q8 : bool = false) : AudioTowerStaging {
             gguf_read_tensor_f32(m, bytes, "mm.a.mlp.1.weight", st.fblob, st.e.proj_w_off, st.e.mm1_out * m1in)
             gguf_read_tensor_f32(m, bytes, "mm.a.mlp.2.weight", st.fblob, st.e.mm2_w_off, st.e.proj_dim * st.e.mm1_out)
         }
+        st.e.blk_bf16 = gguf_tensor_type(m, "a.blk.0.attn_q.weight") == GGML_TYPE_BF16
     }
     fclose(f)
     if (q8) {
         tower_quantize(st)
+    } elif (audio_tower_half_gemms(path)) {   // the file's GEMMs fit halves: the Metal tower's half GEMMs read them where its f32 tile would stage them as halves
+        tower_bake_half_twin(st.fblob, st.wblob, st.e.blk_bf16)
     }
     return <- st
 }
@@ -1341,8 +1455,8 @@ def audio_encode_blocks(t : AudioTower; var s : EncoderState; mel : MelChunk) {
 }
 
 //! the stem, then the blocks with the tower's post-norm folded where the blocks-with-post-norm seat serves (true: `s.xb` holds the
-//! normed rows), else the blocks alone (false: `s.x` holds their output and the caller norms it) - a driver with no post-norm
-//! seat (Metal) serves them at the blocks seat; a post-norm seat that declines asks no second seat, its blocks seat declines alike
+//! normed rows), else the blocks alone (false: `s.x` holds their output and the caller norms it) - a build with no post-norm
+//! seat serves them at the blocks seat; a post-norm seat that declines asks no second seat, its blocks seat declines alike
 def audio_encode_blocks_ln_post(t : AudioTower; var s : EncoderState; mel : MelChunk) : bool {
     audio_encode_stem(t, s, mel)
     let tt = t.n_ctx
@@ -1362,6 +1476,48 @@ def audio_encode_blocks_ln_post(t : AudioTower; var s : EncoderState; mel : MelC
     return false
 }
 
+//! What the blocks-with-tail seat served: nothing, the blocks alone (`s.x` holds their rows), or the blocks and the projector
+//! tail behind them (`s.out` holds the soft tokens)
+enum TowerTailServed {
+    declined
+    blocks
+    tail
+}
+
+typedef TowerBlocksTailGpuFn = function<(t : AudioTower; var s : EncoderState; npos : int64) : TowerTailServed>
+var private g_tw_blocks_tail : TowerBlocksTailGpuFn
+var private g_tw_blocks_tail_set = false
+
+[arch(at="../ARCHITECTURE_MEDIA.md#tower-gpu-hook")]
+def register_tower_blocks_tail_gpu(fn : TowerBlocksTailGpuFn) {
+    g_tw_blocks_tail = fn
+    g_tw_blocks_tail_set = true
+}
+
+//! the stem, then the blocks with the projector tail behind them where the tail seat serves both (true: `s.out` holds the soft
+//! tokens); false leaves the blocks' rows in `s.x` for the CPU tail, whichever chain ran them
+def private audio_encode_blocks_tail(t : AudioTower; var s : EncoderState; mel : MelChunk) : bool {
+    audio_encode_stem(t, s, mel)
+    let tt = t.n_ctx
+    if (!g_tw_blocks_tail_set) {
+        encoder_blocks(t, s, tt)
+        return false
+    }
+    dispatch_phase_encode(tt)
+    var served = TowerTailServed.declined
+    if (empty(g_audio_ref_dir)) {
+        let te = ref_time_ticks()
+        served = invoke(g_tw_blocks_tail, t, s, tt)
+        if (served != TowerTailServed.declined) {
+            asr_prof_add("enc.blocks.gpu", te)
+        }
+    }
+    if (served == TowerTailServed.declined) {
+        encoder_blocks_cpu(t, s, tt)
+    }
+    return served == TowerTailServed.tail
+}
+
 var private g_tw_blocks_ln_post : TowerBlocksGpuFn
 var private g_tw_blocks_ln_post_set = false
 
@@ -1518,11 +1674,15 @@ def private rms_rows_blob_at(var x : array<float>; wp : float const?; dim, rows
 //! Stacking floors rows — ragged tail positions are dropped, not zero-padded.
 [hot_path]
 def audio_encode(t : AudioTower; var s : EncoderState; mel : MelChunk) {
-    audio_encode_blocks(t, s, mel)
+    let rows = audio_tokens_per_chunk(t)
+    if (audio_encode_blocks_tail(t, s, mel)) {
+        diff_stage("out", s.out, rows * t.proj_dim)
+        return
+    }
     trace_tag(TRACE_TAG_ENC_PROJ)
+    let t_tail = ref_time_ticks()
     let tt = t.n_ctx
     let d = t.d_model
-    let rows = audio_tokens_per_chunk(t)
 
     if (t.proj_kind == AudioProjKind.qwen2a) {
         // avg-pool pairs over time (BEFORE the post-LN, not after), then ln_post
@@ -1559,6 +1719,7 @@ def audio_encode(t : AudioTower; var s : EncoderState; mel : MelChunk) {
         gelu_erf(s.ph, rows * t.mm1_out)
         tw_mm_rq(t, s.out, t.mm2_w_off, s.ph, s.xqi, s.xsi, t.mm1_out, t.proj_dim, rows)
     }
+    asr_prof_add("enc.tail", t_tail)
     trace_tag(0)   // clear: the decoder's dispatches must not inherit the projector's color
     diff_stage("out", s.out, rows * t.proj_dim)
 }
diff --git a/modules/dasLLAMA/dasllama/dasllama_audio_embedder.das b/modules/dasLLAMA/dasllama/dasllama_audio_embedder.das
index 7fee9a33d5..31334976f0 100644
--- a/modules/dasLLAMA/dasllama/dasllama_audio_embedder.das
+++ b/modules/dasLLAMA/dasllama/dasllama_audio_embedder.das
@@ -6,6 +6,7 @@ module dasllama_audio_embedder shared public
 
 require dasllama/dasllama_lint public
 require dasllama/dasllama_gemma4a public   // re-exported: a requirer that carries the union must see the family to delete it
+require dasllama/dasllama_audio_tower public   // the same for the whisper-class tower (qwen2a, qwen2.5o, ultravox, voxtral)
 require dasllama/dasllama_image   // image_family_tag — a prepared .dlim routes on its baked tag
 require strings
 
@@ -16,37 +17,44 @@ require strings
 enum AudioKind {
     none
     gemma4a     // the gemma-4 E-series Conformer audio encoder
+    audio_tower // the whisper-class tower with its projector: Qwen2-Audio, Qwen2.5-Omni, Ultravox, Voxtral
 }
 
 struct AudioEmbedder {
     kind : AudioKind = AudioKind.none
     gemma4a : Gemma4aEncoder = Gemma4aEncoder()
+    audio_tower : AudioTowerEncoder = AudioTowerEncoder()
 }
 
 //! Per-encode scratch for whichever family the embedder carries (caller-owned, reused).
 struct AudioState {
     gemma4a : Gemma4aState = Gemma4aState()
+    audio_tower : AudioTowerState = AudioTowerState()
 }
 
 // Stated rather than inferred: the family carrier holds borrowed planes, and a generated
 // teardown would force every module that deletes an AudioEmbedder to see the plane finalizers too.
 def finalize(var e : AudioEmbedder) {
     delete e.gemma4a
+    delete e.audio_tower
 }
 
 def finalize(var s : AudioState) {
     delete s.gemma4a
+    delete s.audio_tower
 }
 
 //! Soft-token width the encoder projects to (must equal the decoder width); 0 = no audio arm.
 def audio_proj_dim(e : AudioEmbedder) : int64 {
     if (e.kind == AudioKind.gemma4a) return e.gemma4a.proj_dim
+    if (e.kind == AudioKind.audio_tower) return audio_tower_encoder_proj_dim(e.audio_tower)
     return 0l
 }
 
 //! The audio family the carrier holds ("gemma4a"; "" for none) — for logs and bench cells.
 def audio_family(e : AudioEmbedder) : string {
     if (e.kind == AudioKind.gemma4a) return "gemma4a"
+    if (e.kind == AudioKind.audio_tower) return audio_tower_encoder_family(e.audio_tower)
     return ""
 }
 
@@ -54,20 +62,33 @@ def audio_family(e : AudioEmbedder) : string {
 //! present, 0 otherwise (missing file, non-GGUF, a vision-only mmproj). Never panics — the
 //! seams gate their audio arms on this.
 def audio_probe_proj_dim(path : string) : int64 {
-    return gemma4a_probe_proj_dim(path)
+    let g4a = gemma4a_probe_proj_dim(path)
+    return g4a > 0l ? g4a : audio_tower_encoder_probe_proj_dim(path)
 }
 
+//! Whether the mmproj at `path` splices its soft tokens with no span marker (see `audio_span_bare`); false for a file
+//! no audio family serves. Never panics.
+def audio_probe_span_bare(path : string) : bool => audio_tower_encoder_probe_span_bare(path)
+
+//! Whether the carried family splices its soft tokens with no span marker around them
+def audio_span_bare(e : AudioEmbedder) : bool => e.kind == AudioKind.audio_tower && audio_tower_encoder_span_bare(e.audio_tower)
+
 //! Load an audio mmproj (gguf, or a prepared ``.dlim`` routed on its baked family tag) as
 //! whichever family it is — probed from the file, never from a knob. Panics by name on a file
 //! no audio family serves; probe first where absence is an answer.
 def load_audio_embedder(path : string) : AudioEmbedder {
     let is_gemma4a_image = path |> ends_with(".dlim") && image_family_tag(path) |> starts_with("gemma4a-")
-    if (is_gemma4a_image || audio_probe_proj_dim(path) > 0l) {
+    if (is_gemma4a_image || gemma4a_probe_proj_dim(path) > 0l) {
         var e = AudioEmbedder(kind = AudioKind.gemma4a)
         e.gemma4a <- load_gemma4a_encoder(path)
         return <- e
     }
-    panic("dasLLAMA audio: '{path}' carries no audio tower any family serves (gemma4a)")
+    if (audio_tower_encoder_image(path) || audio_tower_encoder_probe_proj_dim(path) > 0l) {
+        var e = AudioEmbedder(kind = AudioKind.audio_tower)
+        e.audio_tower <- load_audio_tower_encoder(path)
+        return <- e
+    }
+    panic("dasLLAMA audio: '{path}' carries no audio tower any family serves (gemma4a, or a whisper-class tower: qwen2a, qwen2.5o, ultravox, voxtral)")
     return <- AudioEmbedder()
 }
 
@@ -75,6 +96,7 @@ def load_audio_embedder(path : string) : AudioEmbedder {
 //! ``out`` = nout × proj_dim soft tokens (returns nout). Panics on the no-audio arm.
 def encode_audio_(e : AudioEmbedder; var s : AudioState; samples : array<float> | #; var out : array<float>) : int64 {
     if (e.kind == AudioKind.gemma4a) return gemma4a_encode_all(e.gemma4a, s.gemma4a, samples, out)
+    if (e.kind == AudioKind.audio_tower) return audio_tower_encode_all(e.audio_tower, s.audio_tower, samples, out)
     panic("dasLLAMA audio: encode_audio_ on an embedder with no audio arm")
     return 0l
 }
diff --git a/modules/dasLLAMA/dasllama/dasllama_audio_tower.das b/modules/dasLLAMA/dasllama/dasllama_audio_tower.das
new file mode 100644
index 0000000000..0cffe40fec
--- /dev/null
+++ b/modules/dasLLAMA/dasllama/dasllama_audio_tower.das
@@ -0,0 +1,77 @@
+options gen2
+options _comment_hygiene = true
+options _dasllama_internal = true
+
+module dasllama_audio_tower shared public
+
+require dasllama/dasllama_lint public
+require dasllama/dasllama_audio public   // re-exported: a requirer that carries the encoder must see the tower to delete it
+require dasllama/dasllama_tower   // asr_prof_add: the stage clock
+require dasllama/dasllama_image   // image_family_tag — a prepared .dlim routes on its baked tag
+require strings
+
+//! The whisper-class tower with its projector as an audio carrier family: Qwen2-Audio, Qwen2.5-Omni,
+//! Ultravox, Voxtral. The tower, its mel and its projector are `dasllama_audio`'s; this file is what
+//! the carrier calls.
+
+struct AudioTowerEncoder {
+    tower : AudioTower = AudioTower()
+}
+
+//! Per-encode scratch (caller-owned, reused)
+struct AudioTowerState {
+    enc : EncoderState = EncoderState()
+    made : bool   //! `enc` is sized for the encoder's tower: made at the first encode
+}
+
+def finalize(var e : AudioTowerEncoder) {
+    delete e.tower
+}
+
+def finalize(var s : AudioTowerState) {
+    delete s.enc
+}
+
+//! The projection width of the mmproj at `path` where the tower serves it, 0 otherwise. Never panics.
+def audio_tower_encoder_probe_proj_dim(path : string) : int64 => audio_tower_probe_proj_dim(path)
+
+//! Whether the mmproj at `path` splices its soft tokens with no span marker; false for a file the tower does not serve
+def audio_tower_encoder_probe_span_bare(path : string) : bool => audio_tower_probe_span_bare(path)
+
+//! Whether `path` is a prepared image of this family
+def audio_tower_encoder_image(path : string) : bool
+    => path |> ends_with(".dlim") && image_family_tag(path) |> starts_with("tower-")
+
+def load_audio_tower_encoder(path : string) : AudioTowerEncoder {
+    var e = AudioTowerEncoder()
+    e.tower <- load_audio_tower(path)
+    return <- e
+}
+
+def audio_tower_encoder_proj_dim(e : AudioTowerEncoder) : int64 => e.tower.proj_dim
+
+//! the projector the file carries, as the log names it
+def audio_tower_encoder_family(e : AudioTowerEncoder) : string => "{e.tower.proj_kind}"
+
+//! Whether the encoder's soft tokens splice with no span marker around them
+def audio_tower_encoder_span_bare(e : AudioTowerEncoder) : bool => audio_span_bare(e.tower.proj_kind)
+
+//! The tower over a whole clip: a 30 s mel chunk at a time, each chunk's soft tokens appended to `out`; answers the rows
+def audio_tower_encode_all(e : AudioTowerEncoder; var s : AudioTowerState; samples : array<float> | #; var out : array<float>) : int64 {
+    if (!s.made) {
+        s.enc <- make_encoder_state(e.tower)
+        s.made = true
+    }
+    let t_mel = ref_time_ticks()
+    var inscope chunks <- log_mel_chunks(samples, e.tower.n_mel)
+    asr_prof_add("enc.mel", t_mel)
+    let rows = audio_tokens_per_chunk(e.tower)
+    out |> reserve(length(out) + length(chunks) * int(rows * e.tower.proj_dim))
+    for (chunk in chunks) {
+        audio_encode(e.tower, s.enc, chunk)
+        for (i in range64(rows * e.tower.proj_dim)) {
+            out |> push(s.enc.out[i])
+        }
+    }
+    return long_length(chunks) * rows
+}
diff --git a/modules/dasLLAMA/dasllama/dasllama_blocks.das b/modules/dasLLAMA/dasllama/dasllama_blocks.das
index f064835d63..1fe8666dbe 100644
--- a/modules/dasLLAMA/dasllama/dasllama_blocks.das
+++ b/modules/dasLLAMA/dasllama/dasllama_blocks.das
@@ -2210,7 +2210,11 @@ def forward_prefill_embd(t : Model; var s : Session; embd : array<float>; npos,
     prof_add("embed", ts_embed)
     if (has_ple(t.config)) {  // gemma-4 E-series: PLE side input (padding-token gather for the media path)
         let ts_ple = prof_ticks()
-        ple_pre_prefill_pad_gated(t, s, npos, start_pos)
+        if (long_length(s.embd_ids) >= src_off + npos) {   // a media body: its text rows take their own tokens' side input
+            ple_pre_prefill_gated(t, s, s.embd_ids, src_off, npos, start_pos)
+        } else {
+            ple_pre_prefill_pad_gated(t, s, npos, start_pos)
+        }
         prof_add("ple", ts_ple)
     }
     // the non-causal image span (gemma vision): span queries attend
@@ -2247,6 +2251,49 @@ def embed_text_rows_strided(t : Model; tokens : array<int64>; var dst : array<fl
     }
 }
 
+//! One prefill body's rows at the decoder's row stride: ``head`` text, ``n_media`` media rows of width ``src_w``,
+//! ``tail`` text. A deepstack decoder's stride is (1+n)·dim - a text row and a dim-wide media row keep a zero tail.
+//! On a gemma-4 E-series decoder the session takes each row's token id for ``eval_embd_body_``, which spends them.
+def media_body_rows_(t : Model; var s : Session; head : array<int64>; rows : array<float>; n_media, src_w : int64;
+                     tail : array<int64>; var embd : array<float>) {
+    let rw = t.config.dim * (1l + t.config.n_deepstack)
+    let n_head = long_length(head)
+    let npos = n_head + n_media + long_length(tail)
+    embd |> clear()
+    embd |> ensure_capacity(npos * rw)
+    embd |> resize(npos * rw)
+    embed_text_rows_strided(t, head, embd, 0l, rw)
+    for (r in range64(n_media)) {
+        unsafe {
+            memcpy(addr(embd[(n_head + r) * rw]), addr(rows[r * src_w]), src_w * 4l)
+        }
+    }
+    embed_text_rows_strided(t, tail, embd, n_head + n_media, rw)
+    s.embd_ids |> clear()
+    if (has_ple(t.config)) {
+        s.embd_ids |> resize(npos)
+        for (p in range64(n_head)) {
+            s.embd_ids[p] = head[p]
+        }
+        for (p in range64(long_length(tail))) {
+            s.embd_ids[n_head + n_media + p] = tail[p]
+        }
+    }
+}
+
+//! Prefill ``npos`` rows whose [span_lo, span_hi) are a NON-CAUSAL span (span_hi <= span_lo = every row causal);
+//! a non-zero merged ``grid`` ropes the span on the image-grid walk.
+def eval_embd_body_(t : Model; var s : Session; embd : array<float>; npos, span_lo, span_hi : int64; grid : int2) {
+    if (span_hi > span_lo && grid.x > 0) {
+        eval_embd_span_mrope_(t, s, embd, npos, span_lo, span_hi, int64(grid.x), int64(grid.y))
+    } elif (span_hi > span_lo) {
+        eval_embd_span_(t, s, embd, npos, span_lo, span_hi)
+    } else {
+        eval_embd_(t, s, embd, npos)
+    }
+    s.embd_ids |> clear()
+}
+
 //! Fill ``dst[at*dim ..]`` with the embedding rows of ``tokens`` (embed_scale applied) — the
 //! text-span half of a multimodal prefill buffer.
 def embed_text_rows(t : Model; tokens : array<int64>; var dst : array<float>; at : int64) {
diff --git a/modules/dasLLAMA/dasllama/dasllama_canary.das b/modules/dasLLAMA/dasllama/dasllama_canary.das
index 69fa24908c..07c236940f 100644
--- a/modules/dasLLAMA/dasllama/dasllama_canary.das
+++ b/modules/dasLLAMA/dasllama/dasllama_canary.das
@@ -1161,18 +1161,26 @@ def canary_encode(m : CanaryEncoder; var st : CanaryState) : int64 {
     dispatch_phase_encode(conv_s2_out(conv_s2_out(conv_s2_out(st.n_len))))
 
     var tt = -1l
+    var ts = ref_time_ticks()
     if (g_cn_front_set) {
         tt = invoke(g_cn_front, m, st)
+        if (tt >= 0l) {
+            asr_prof_add("cn.front.gpu", ts)
+        }
     }
     if (tt < 0l) {
         if (!st.mel_ready) {
             canary_mel_spectrum(m, st)
+            asr_prof_add("cn.mel", ts)
+            ts = ref_time_ticks()
         }
         tt = cn_front_cpu(m, st)
+        asr_prof_add("cn.front", ts)
     }
 
     let ww = 2l * tt - 1l
     var gpu_served = false
+    ts = ref_time_ticks()
     if (g_cn_gpu_set) {
         gpu_served = invoke(g_cn_gpu, m, st, tt, ww)
     }
@@ -1180,11 +1188,14 @@ def canary_encode(m : CanaryEncoder; var st : CanaryState) : int64 {
         canary_pos_table(m, st, tt, ww)
         cn_blocks_cpu(m, st, tt, ww)
     }
+    asr_prof_add(gpu_served ? "cn.blocks.gpu" : "cn.blocks", ts)
 
     // perception.proj: encoder rows (d) -> decoder embedding (proj_dim)
+    ts = ref_time_ticks()
     ensure_length(st.out, tt * m.proj_dim)
     cn_mm_rq(m, st.out, m.proj_w, st.x, st.xqi, st.xsi, d, m.proj_dim, tt)
     add_bias_rows(st.out, m.blob, m.proj_b, m.proj_dim, tt)
+    asr_prof_add("cn.proj", ts)
     return tt
 }
 
@@ -1225,11 +1236,11 @@ def canary_transcribe(dec : Model; enc : CanaryEncoder; var s : CanaryAsrSession
     let im_start = special_id(dec, "<|im_start|>")
     let im_end = special_id(dec, "<|im_end|>")   // = the text EOS (151645)
     // SALM "qwen" prompt: <|im_start|>user\nTranscribe the following: <AUDIO><|im_end|>\n<|im_start|>assistant\n
-    var head : array<int64>
+    var inscope head : array<int64>
     head |> push(im_start)
     head |> push_from(encode_(dec, "user\n", false, false))
     head |> push_from(encode_(dec, "Transcribe the following: ", false, false))
-    var tail : array<int64>
+    var inscope tail : array<int64>
     tail |> push(im_end)
     tail |> push_from(encode_(dec, "\n", false, false))
     tail |> push(im_start)
@@ -1238,24 +1249,19 @@ def canary_transcribe(dec : Model; enc : CanaryEncoder; var s : CanaryAsrSession
     let n_head = long_length(head)
     let npos = n_head + n_audio + long_length(tail)
     asr_ctx_guard(n_audio, npos, dec.config.seq_len)
-    var embd : array<float>
-    embd |> resize(int(npos * dim))
-    embed_text_rows(dec, head, embd, 0l)
-    for (i in range64(n_audio * dim)) {
-        embd[n_head * dim + i] = s.cst.out[i]
-    }
-    embed_text_rows(dec, tail, embd, n_head + n_audio)
+    var inscope embd : array<float>
+    media_body_rows_(dec, s.qctx, head, s.cst.out, n_audio, dim, tail, embd)
 
     let tpf = ref_time_ticks()
     s.qctx.n_past = 0l   // fresh sequence per transcribe
-    eval_embd_(dec, s.qctx, embd, npos)
+    eval_embd_body_(dec, s.qctx, embd, npos, 0l, 0l, int2(0))
     asr_prof_add("cn.prefill", tpf)
 
     let max_new = min(dec.config.seq_len - npos - 1l, CN_MAX_NEW)
-    var one : array<int64>
+    var inscope one : array<int64>
     one |> resize(1)
-    var toks : array<int>
-    var raw : array<string>
+    var inscope toks : array<int>
+    var inscope raw : array<string>
     toks |> reserve(128)   // typical transcription length; grows if a clip runs longer
     raw |> reserve(128)
     var plog_sum = 0.0lf
@@ -1281,7 +1287,7 @@ def canary_transcribe(dec : Model; enc : CanaryEncoder; var s : CanaryAsrSession
         to_log(LOG_WARNING, "dasLLAMA canary: decode budget exhausted at {max_new} tokens - transcript is TRUNCATED\n")
     }
 
-    var seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE,
+    var inscope seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE,
         text = strip(join(raw, "")))
     seg.tokens := toks
     if (!empty(toks)) {
diff --git a/modules/dasLLAMA/dasllama/dasllama_chat.das b/modules/dasLLAMA/dasllama/dasllama_chat.das
index 5b7d7e176a..69928cad9c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_chat.das
+++ b/modules/dasLLAMA/dasllama/dasllama_chat.das
@@ -67,8 +67,29 @@ struct ChatSession {
     image_rows : array<float>             // encoded image soft tokens awaiting the next respond()
     n_image_rows : int64                  // row count in image_rows (each vision.proj_dim wide)
     image_grid : int2                     // the merged nx×ny when the family ropes with grid positions (qwen mrope); (0,0) = sequential
+    pending_spans : array<MediaMark>      // media the pending user turn carries INLINE: each span's positions render among the turn's tokens
 }
 
+//! One media span a user turn carries inline: `n_rows` positions keyed by the media's content hash, spliced after
+//! `text_before` bytes of the turn's text under the family's image or audio markers (none for a bare span).
+struct MediaMark {
+    key : uint64
+    n_rows : int64
+    text_before : int
+    is_image : bool
+    bare : bool
+}
+
+//! The prompt entry that stands for row `row` of the media keyed `key`: never a vocab id (below zero), the same for the
+//! same media at the same row, so a prefix match runs across a span as it does across text.
+def media_position_id(key : uint64; row : int64) : int64 {
+    let h = hash_combine64(key, uint64(row))
+    return -2l - int64(h >> 2ul)
+}
+
+//! whether a prompt entry stands for a media row rather than a token
+def is_media_position(id : int64) : bool => id < -1l
+
 // Stated rather than inferred: the tower holds borrowed planes, and a generated teardown
 // would force every module that deletes a ChatSession to see the plane finalizers too.
 // Each field's own finalizer does the real work — this only names them in one place.
@@ -89,6 +110,7 @@ def finalize(var c : ChatSession) {
     delete c.embedder
     delete c.embedder_scratch
     delete c.image_rows
+    delete c.pending_spans
 }
 
 // ===== Chat-template resolution =====
@@ -156,6 +178,55 @@ def private chat_template_of_kind(kind : string) : ChatTemplate {
     return <- arch_chat(kind)
 }
 
+//! the literal system text of the first `opener` ... `<|im_end|>` span of a template that holds no Jinja expression;
+//! `quoted`: the span sits inside a string literal, where a quote ends the literal and an expression follows
+def private chatml_literal_system(src, opener : string; quoted : bool) : string {
+    var at = find(src, opener)
+    while (at >= 0) {
+        let from = at + length(opener)
+        let to = find(src, "<|im_end|>", from)
+        break if (to < 0)
+        let text = chatml_literal(src, from, to, quoted)
+        return text if (!empty(text))
+        at = find(src, opener, at + 1)
+    }
+    return ""
+}
+
+//! `src[from, to)` where it is literal text, "" where a Jinja expression sits in it (the caller's own system turn)
+def private chatml_literal(src : string; from, to : int; quoted : bool) : string {
+    let text = slice(src, from, to)
+    let expr = find(text, "\{") >= 0 || (quoted && (find(text, "'") >= 0 || find(text, "\"") >= 0))
+    return expr ? "" : text
+}
+
+//! The system text a ChatML template states for a conversation that opens with no system message, "" where it
+//! states none; the newline after the role is written out in a template's text and escaped in its string literals
+def private chatml_default_system(src : string) : string {
+    let plain = chatml_literal_system(src, "<|im_start|>system\n", false)
+    return empty(plain) ? chatml_literal_system(src, "<|im_start|>system\\n", true) : plain
+}
+
+//! `src` from `at` up to the next `stop`, "" where either is missing
+def private text_between(src, open, stop : string) : string {
+    let at = find(src, open)
+    return "" if (at < 0)
+    let from = at + length(open)
+    let to = find(src, stop, from)
+    return to < 0 ? "" : slice(src, from, to)
+}
+
+//! The header a Llama-3.1+ template writes into every system turn, read off the template: its knowledge-cutoff line,
+//! and the date line's fixed date where the template has no clock to ask. A template with no such header (Llama-3.0)
+//! leaves the fields as they stand.
+def private llama_system_header(src : string; var ct : ChatTemplate) {
+    let cutoff = text_between(src, "Cutting Knowledge Date: ", "\\n")
+    return if (empty(cutoff) || find(src, "Today Date: ") < 0)
+    ct.system_lead = "Cutting Knowledge Date: {cutoff}\n"
+    ct.system_dated = true
+    ct.system_date = find(src, "strftime_now") >= 0 ? "" : text_between(src, "set date_string = \"", "\"")
+}
+
 //! The chat template for a loaded model: sniff the GGUF's embedded `tokenizer.chat_template`
 //! first, falling back to the arch heuristic. GGUF general.architecture is "llama" for both
 //! Llama-3 (BPE) and Llama-2 (SentencePiece), so the fallback disambiguates by tokenizer backend.
@@ -163,7 +234,16 @@ def chat_template(m : Model) : ChatTemplate {
     let kind = detect_chat_kind(m.chat_template_str)
     if (!empty(kind)) {
         var ct <- chat_template_of_kind(kind)
+        if (kind == "gemma4" && find(m.chat_template_str, "thought\\n<channel|>") < 0) {
+            // the E-series template opens a non-thinking model turn bare, where the larger models' closes an empty
+            // thought channel first: with that channel ahead of it an E-series model writes its reasoning as the answer
+            ct.assistant_open.parts := ct.assistant_open_think.parts
+        }
+        if (kind == "llama") {
+            llama_system_header(m.chat_template_str, ct)
+        }
         if (kind == "qwen2") {
+            ct.default_system = chatml_default_system(m.chat_template_str)
             let gen = rfind(m.chat_template_str, "add_generation_prompt")
             if (gen >= 0) {
                 let tail = slice(m.chat_template_str, gen)
@@ -368,11 +448,13 @@ def private render_assistant_open(m : Model; c : ChatSession; var out : array<in
 // mode — the tool block wrapping the verbatim tool JSONs (one per line, the Qwen shape). The
 // other modes place their definitions elsewhere (developer turn, <|tool> blocks, user prefix).
 def private system_content(c : ChatSession) : string {
+    let said = empty(c.system) ? c.tmpl.default_system : c.system
+    let base = c.tmpl.system_dated ? dated_system(c, said) : said
     if (empty(c.tools_json) || c.tmpl.tool_mode != ToolMode.hermes) {
-        return c.system
+        return base
     }
     var parts : array<string>
-    parts |> push(empty(c.system) ? c.tmpl.tool_sys_prelude : "{c.system}\n\n{c.tmpl.tool_sys_prelude}")
+    parts |> push(empty(base) ? c.tmpl.tool_sys_prelude : "{base}\n\n{c.tmpl.tool_sys_prelude}")
     parts |> push_from(c.tools_json)
     parts |> push(c.tmpl.tool_sys_epilogue)
     let s = join(parts, "\n")
@@ -380,6 +462,21 @@ def private system_content(c : ChatSession) : string {
     return s
 }
 
+var private g_chat_date = ""   //! the date a dated system turn states in place of today's (`set_chat_date_`)
+
+//! Pin the date a dated system turn states ("26 Jul 2024"); "" returns it to the day the turn renders. For a caller
+//! whose prompt must not move with the calendar: a test's pinned stream, a benchmark's fixed prompt.
+def set_chat_date_(date : string) {
+    g_chat_date = date
+}
+
+//! A Llama-3.1+ system turn's content: the environment line a tool-carrying turn opens with, the template's lead
+//! (its knowledge-cutoff line), the date line, then the caller's system text.
+def private dated_system(c : ChatSession; said : string) : string {
+    let date = !empty(g_chat_date) ? g_chat_date : (!empty(c.tmpl.system_date) ? c.tmpl.system_date : format_time(get_clock(), "%d %b %Y"))   // clock: control — the date the turn states, not timing
+    return "{empty(c.tools_json) ? "" : "Environment: ipython\n"}{c.tmpl.system_lead}Today Date: {date}\n\n{strip(said)}"
+}
+
 // The first-turn system block, shared by the text and audio prompt paths: the think gate spliced
 // before the content, tool markers split where declared. Returns the text to FOLD into the user
 // turn instead when the family has no system role (gemma-2/3); "" = rendered or nothing to do.
@@ -497,6 +594,8 @@ def private render_prompt(m : Model; c : ChatSession; var out : array<int64>) :
         split_on_tool_markers(m, c, user_content, tp)
         render_parts_spliced(m, c.tmpl.user.parts, tp, out)
         delete tp
+    } elif (!empty(c.pending_spans)) {
+        render_user_spans(m, c, user_content, out)
     } else {
         render_parts(m, c.tmpl.user.parts, user_content, out)
     }
@@ -513,6 +612,53 @@ def private render_prompt(m : Model; c : ChatSession; var out : array<int64>) :
     return opening
 }
 
+//! The user turn with its media spans inline: the turn's text cut at each span's offset, the span's marker pair around
+//! its position ids. A text chunk breaks at a span, so no BPE merge crosses one; text a family folds ahead of the
+//! user text (a system prompt with no role of its own) rides ahead of the first span.
+def private render_user_spans(m : Model; c : ChatSession; user_content : string; var out : array<int64>) {
+    var inscope lead : array<ChatPart>
+    var inscope after : array<ChatPart>
+    var seen = false
+    for (p in c.tmpl.user.parts) {
+        if (p.kind == ChatPartKind.content) {
+            seen = true
+        } elif (seen) {
+            after |> push(p)
+        } else {
+            lead |> push(p)
+        }
+    }
+    let folded = length(user_content) - length(c.pending)
+    var cur = 0
+    for (sp in c.pending_spans) {
+        let cut = folded + clamp(sp.text_before, cur - folded, length(c.pending))
+        if (cut > cur) {
+            lead |> push(chat_content())
+        }
+        if (!sp.bare) {
+            lead |> push_from(sp.is_image ? c.tmpl.image_pre.parts : c.tmpl.audio_pre.parts)
+        }
+        render_user_span_text(m, lead, user_content, cur, cut, out)
+        out |> reserve(long_length(out) + sp.n_rows)
+        for (r in range64(sp.n_rows)) {
+            out |> push(media_position_id(sp.key, r))
+        }
+        lead |> clear()
+        if (!sp.bare) {
+            lead |> push_from(sp.is_image ? c.tmpl.image_post.parts : c.tmpl.audio_post.parts)
+        }
+        cur = cut
+    }
+    lead |> push(chat_content())
+    lead |> push_from(after)
+    render_user_span_text(m, lead, user_content, cur, length(user_content), out)
+}
+
+//! `parts` rendered over `text[from, to)`
+def private render_user_span_text(m : Model; parts : array<ChatPart>; text : string; from, to : int; var out : array<int64>) {
+    render_parts(m, parts, to > from ? slice(text, from, to) : "", out)
+}
+
 // The pending tool results in the family's own framing (everything but hermes): harmony/llama
 // result turns, gemma-4's in-turn response blocks, mistral's bracket pair. Explicit names
 // (tool_call_id mapped back) win; missing ones pair to the last call set positionally, then `unknown`.
@@ -559,20 +705,20 @@ def private render_tool_results(m : Model; c : ChatSession; var out : array<int6
 //! Render an AUDIO turn's prefill as two spans around the soft-token splice point — the text
 //! chunks break at the media boundary so BPE merges never cross the media (the llama-mtmd-cli
 //! shape). Public with ``create_chat_renderer_``: the render-only seam.
-def render_prompt_audio(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>) {
-    render_prompt_media(m, c, c.tmpl.audio_pre.parts, c.tmpl.audio_post.parts, head, tail)
+def render_prompt_audio(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
+    render_prompt_media(m, c, c.tmpl.audio_pre.parts, c.tmpl.audio_post.parts, head, tail, text_before)
 }
 
 //! Render an IMAGE turn's prefill: same two-span contract as ``render_prompt_audio`` (gemma-4:
 //! `<|image>` … `<image|>`).
-def render_prompt_image(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>) {
-    render_prompt_media(m, c, c.tmpl.image_pre.parts, c.tmpl.image_post.parts, head, tail)
+def render_prompt_image(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
+    render_prompt_media(m, c, c.tmpl.image_pre.parts, c.tmpl.image_post.parts, head, tail, text_before)
 }
 
-// Two spans around the media splice point (head before, tail after) — matches llama-mtmd-cli
-// exactly, whose text chunks break at media boundaries so BPE merges never cross the media.
+//! Two spans around the media splice (head before, tail after): the text chunks break at the media, so no BPE merge
+//! crosses it. `text_before` bytes of the pending user text render ahead of the media: 0 puts it at the head of the turn.
 def private render_prompt_media(m : Model; c : ChatSession; pre_parts, post_parts : array<ChatPart>;
-                                var head : array<int64>; var tail : array<int64>) {
+                                var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
     if (c.first && c.tmpl.add_bos) {
         head |> push(bos_id(m))
     }
@@ -598,8 +744,16 @@ def private render_prompt_media(m : Model; c : ChatSession; pre_parts, post_part
             before |> push(p)
         }
     }
-    render_parts(m, before, "", head)
+    // the folded system text, where the family folds one, rides ahead of the user text
+    let lead = text_before > 0 ? length(user_content) - length(c.pending) + min(text_before, length(c.pending)) : 0
+    if (lead > 0) {
+        before |> push(chat_content())
+    }
+    render_parts(m, before, lead > 0 ? slice(user_content, 0, lead) : "", head)
     render_parts(m, pre_parts, "", head)
+    if (lead > 0) {
+        user_content = slice(user_content, lead)
+    }
     var tail_parts := post_parts
     tail_parts |> push(chat_content())
     if (think_turn_active_(c) && !empty(c.tmpl.assistant_open_think.parts)) {
@@ -633,6 +787,7 @@ def private consume_pending_(var c : ChatSession) {
     c.image_rows |> clear()
     c.n_image_rows = 0l
     c.image_grid = int2(0)
+    c.pending_spans |> clear()
     c.turn_open = false                // ditto the leaked-turn close; re-set AFTER consume where a call leaves it open
 }
 
@@ -774,14 +929,33 @@ def add_user_image_rows_(m : Model; var c : ChatSession; var rows : array<float>
     c.image_grid = grid
 }
 
-//! Queue PRE-ENCODED audio soft-token rows (what `encode_audio` emits — `dim`-wide on every
-//! family, length-checked) for the next respond(). MOVES `rows`; works on a plain chat — no
-//! tower needed: the carrier path for a model whose audio arm the AudioEmbedder serves.
-def add_user_audio_rows_(m : Model; var c : ChatSession; var rows : array<float>; n_rows : int64) {
+//! Mark the pending user turn as carrying a media span INLINE: it renders with `n_rows` position ids
+//! (`media_position_id` over `key`) `text_before` bytes into its text. Spans queue in text order; their rows are the
+//! caller's to eval where the ids stand. Panics where the template has no markers for the kind and the span is not bare.
+def add_user_span_(m : Model; var c : ChatSession; key : uint64; n_rows : int64; text_before : int; is_image, bare : bool) {
+    if (n_rows <= 0l) {
+        panic("dasLLAMA chat: a media span of {n_rows} rows")
+    }
+    if (is_image && (empty(c.tmpl.image_pre.parts) || !image_vocab_ok(m, c.tmpl))) {
+        panic("dasLLAMA chat: this model's chat template declares no usable image span markers - it has no vision arm")
+    }
+    if (!is_image && !bare && (empty(c.tmpl.audio_pre.parts) || !audio_vocab_ok(m, c.tmpl))) {
+        panic("dasLLAMA chat: this model's chat template declares no usable audio span markers - it has no audio arm")
+    }
+    if (!empty(c.pending_spans) && c.pending_spans[length(c.pending_spans) - 1].text_before > text_before) {
+        panic("dasLLAMA chat: media spans queue in text order - a span at {text_before} after one at {c.pending_spans[length(c.pending_spans) - 1].text_before}")
+    }
+    c.pending_spans |> push(MediaMark(key = key, n_rows = n_rows, text_before = text_before, is_image = is_image, bare = bare))
+}
+
+//! Queue PRE-ENCODED audio soft-token rows (what `encode_audio` emits — `dim`-wide, length-checked) for the next
+//! respond(). MOVES `rows`; works on a plain chat, no tower needed. `bare` is the encoder's `audio_span_bare`: its
+//! rows take no span marker, so the template owes none.
+def add_user_audio_rows_(m : Model; var c : ChatSession; var rows : array<float>; n_rows : int64; bare : bool = false) {
     if (c.n_image_rows > 0l) {
         panic("dasLLAMA chat: an image is already queued this turn - one media kind per turn")
     }
-    if (empty(c.tmpl.audio_pre.parts) || !audio_vocab_ok(m, c.tmpl)) {
+    if (!bare && (empty(c.tmpl.audio_pre.parts) || !audio_vocab_ok(m, c.tmpl))) {
         panic("dasLLAMA chat: this model's chat template declares no usable audio span markers - it has no audio arm")
     }
     if (long_length(rows) != n_rows * m.config.dim) {
@@ -858,15 +1032,15 @@ def render_turn_marked_(m : Model; c : ChatSession) : RenderedTurn {
 //! `render_turn_`'s IMAGE twin: the turn's prefill as the two token spans that bracket the image
 //! soft-token splice — `head` before the rows, `tail` (generation prompt, think-suppress) after.
 //! Render-only: no KV, no embedder — the rows come from `encode_image` on the caller's own.
-def render_turn_image_(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>) {
-    render_prompt_image(m, c, head, tail)
+def render_turn_image_(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
+    render_prompt_image(m, c, head, tail, text_before)
     render_think_suppress(m, c, tail)
 }
 
 //! `render_turn_`'s AUDIO twin: the same two-span contract around the audio soft-token splice
 //! (the template's audio span markers). The rows come from the family's audio encoder.
-def render_turn_audio_(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>) {
-    render_prompt_audio(m, c, head, tail)
+def render_turn_audio_(m : Model; c : ChatSession; var head : array<int64>; var tail : array<int64>; text_before : int = 0) {
+    render_prompt_audio(m, c, head, tail, text_before)
     render_think_suppress(m, c, tail)
 }
 
@@ -1511,28 +1685,14 @@ def respond_(m : Model; var c : ChatSession; params : SamplingParams;
 // the media-quantum embd rows: head/tail text around the spliced media. Deepstack decoders
 // take (1+n)·dim-wide rows — text tails stay zero (the eval seam splits slice 0 and adds the
 // rest per layer); audio rows are dim-wide on every family, zero-tailed like text.
-def private assemble_media_embd(m : Model; c : ChatSession; head, tail : array<int64>;
+def private assemble_media_embd(m : Model; var c : ChatSession; head, tail : array<int64>;
                                 is_image : bool; var embd : array<float>) {
     let dim = m.config.dim
-    let rw = dim * (1l + m.config.n_deepstack)
-    let n_head = long_length(head)
-    let n_media = is_image ? c.n_image_rows : c.n_audio_rows
-    let npos = n_head + n_media + long_length(tail)
-    embd |> ensure_capacity(npos * rw)
-    embd |> resize(npos * rw)
-    embed_text_rows_strided(m, head, embd, 0l, rw)
-    if (is_image) {   // the embedder's rows match rw (the create_chat pair check)
-        for (i in range64(n_media * rw)) {
-            embd[n_head * rw + i] = c.image_rows[i]
-        }
+    if (is_image) {   // the embedder's rows match the decoder's stride (the create_chat pair check)
+        media_body_rows_(m, c.session, head, c.image_rows, c.n_image_rows, dim * (1l + m.config.n_deepstack), tail, embd)
     } else {
-        for (r in range64(n_media)) {
-            for (i in range64(dim)) {
-                embd[(n_head + r) * rw + i] = c.audio_rows[r * dim + i]
-            }
-        }
+        media_body_rows_(m, c.session, head, c.audio_rows, c.n_audio_rows, dim, tail, embd)
     }
-    embed_text_rows_strided(m, tail, embd, n_head + n_media, rw)
 }
 
 //! One generated token of a respond: false ends the turn - the template's own stop, or a
diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index cad710d592..54a67b80a7 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -386,6 +386,20 @@ def ple_pre_prefill_pad(t : Model; var s : Session; npos : int64) {
     invoke(g_ple_pre_prefill_pad, t, s, npos)
 }
 
+//! The prefill pre-step over rows `tokens[off ..]`: offered to the device driver with the ids stashed, the CPU
+//! pre-step on decline. The model_proj GEMM inside the finish is the whole cost, so an eligible driver gets the offer.
+def ple_pre_prefill_gated(t : Model; var s : Session; tokens : array<int64>; off, npos, start_pos : int64) {
+    s.ple_gpu_tokens |> resize(npos)
+    for (p in range64(npos)) {
+        s.ple_gpu_tokens[p] = tokens[off + p]
+    }
+    if (g_ple_gpu_gate_set && invoke(g_ple_gpu_gate, t, s, npos, start_pos)) {
+        s.ple_gpu_pending = true
+    } else {
+        ple_pre_prefill(t, s, s.ple_gpu_tokens, npos)
+    }
+}
+
 //! The embd-prefill twin of the token path's PLE gate: offer the pre-step to the device driver
 //! (pad ids stashed — the media path has no tokens), CPU pad impl on decline. The model_proj
 //! GEMM inside the finish is the whole cost, so an eligible driver must get the offer here too.
@@ -1514,6 +1528,10 @@ struct ChatTemplate {
     add_bos : bool = false                    // prepend the tokenizer BOS at conversation start
     prelude : ChatTurn = ChatTurn()           // conversation-start parts after BOS (glm4moe: [gMASK]<sop>)
     system : ChatTurn = ChatTurn()
+    default_system : string = ""              // the system text the model's own template states for a conversation that opens with none
+    system_lead : string = ""                 // text the template writes ahead of every system turn's content (Llama-3.1+: the knowledge-cutoff line)
+    system_dated : bool = false               // the template follows `system_lead` with a "Today Date:" line, so a system turn renders on every conversation
+    system_date : string = ""                 // that line's date where the template fixes one; "" = the day the turn renders
     user : ChatTurn = ChatTurn()
     assistant_open : ChatTurn = ChatTurn()
     assistant_close : ChatTurn = ChatTurn()   // empty = derive from the user turn's tail parts
@@ -2520,6 +2538,7 @@ struct Session {
     @scratch ple_proj : array<float>     // model-proj scratch for the pre-step (npos x n_layers x ple)
     @scratch ple_gate : array<float>     // per-(position) gate vector for the layer block (npos x ple)
     @scratch ple_gpu_tokens : array<int64>  // stashed token rows for a driver-owned pre-step (see register_ple_gpu_gate)
+    @scratch embd_ids : array<int64>        //!< the token id of each row of the embedding body about to prefill, 0 for a media row; empty = every row the padding token's
     ple_gpu_pending : bool      // forward_prefill skipped the CPU pre-step — the engaged driver builds it
     @scratch embed_gpu_tokens : array<int64>
     embed_gpu_pending : bool
@@ -3422,6 +3441,31 @@ def create_kv_pool_(c : Config; page_rows : int64; kdt, vdt : KVDtype) : KVPool
     return <- p
 }
 
+let KV_POOL_RESERVE_BYTES = 4l * 1024l * 1024l * 1024l
+
+//! Reserve address room for `positions` cached positions, up to KV_POOL_RESERVE_BYTES: growth inside the
+//! reserve moves no blob. The reserve is untouched memory - pages commit as groups are written.
+def kv_pool_reserve(var p : KVPool; positions : int64) {
+    var group_bytes = 0l
+    for (kb, vb in p.krow_bytes, p.vrow_bytes) {
+        group_bytes += (kb + vb) * p.page_rows
+    }
+    return if (group_bytes <= 0l)
+    let groups = min((positions + p.page_rows - 1l) / p.page_rows, KV_POOL_RESERVE_BYTES / group_bytes)
+    for (b in range64(p.nblobs)) {
+        p.kblobs[b] |> reserve(groups * p.page_rows * p.krow_bytes[b])
+        p.vblobs[b] |> reserve(groups * p.page_rows * p.vrow_bytes[b])
+    }
+}
+
+//! A group is written before it is read - a recycled one already hands out stale rows - so the new rows stay unfilled.
+def private kv_blob_grow(var blob : array<uint8>; need : int64) {
+    if (long_capacity(blob) < need) {
+        blob |> reserve(need)
+    }
+    blob |> resize_no_init(need)
+}
+
 // Double the pool's group capacity. Every blob resizes IN PLACE — a hoisted cache pointer would
 // dangle, which is why kv_ensure runs at the top of the forward entries, before any hoist.
 [cold_path]   // doubling growth: amortized O(1) per page, and never on a flat session
@@ -3429,8 +3473,8 @@ def private kv_pool_grow(var p : KVPool) {
     let oldcap = p.capacity_groups
     let newcap = oldcap <= 0l ? 4l : oldcap * 2l
     for (b in range64(p.nblobs)) {
-        p.kblobs[b] |> reserve_resize(newcap * p.page_rows * p.krow_bytes[b])
-        p.vblobs[b] |> reserve_resize(newcap * p.page_rows * p.vrow_bytes[b])
+        kv_blob_grow(p.kblobs[b], newcap * p.page_rows * p.krow_bytes[b])
+        kv_blob_grow(p.vblobs[b], newcap * p.page_rows * p.vrow_bytes[b])
     }
     p.refcnt |> resize(newcap)
     p.gen |> resize(newcap)
@@ -6191,15 +6235,7 @@ def forward_prefill(t : Model; var s : Session; tokens : array<int64>; npos, sta
     }
     if (has_ple(c)) {  // gemma-4 E-series: build each position's per-(layer) side input before the stack
         let ts_ple = prof_ticks()
-        if (g_ple_gpu_gate_set && invoke(g_ple_gpu_gate, t, s, npos, start_pos)) {
-            s.ple_gpu_tokens |> resize(npos)
-            for (p in range64(npos)) {
-                s.ple_gpu_tokens[p] = tokens[p]
-            }
-            s.ple_gpu_pending = true
-        } else {
-            ple_pre_prefill(t, s, tokens, npos)
-        }
+        ple_pre_prefill_gated(t, s, tokens, 0l, npos, start_pos)
         prof_add("ple", ts_ple)
     }
 
diff --git a/modules/dasLLAMA/dasllama/dasllama_convert.das b/modules/dasLLAMA/dasllama/dasllama_convert.das
index 5cb790fc0e..be17efd907 100644
--- a/modules/dasLLAMA/dasllama/dasllama_convert.das
+++ b/modules/dasLLAMA/dasllama/dasllama_convert.das
@@ -35,6 +35,32 @@ def rd_f32(b : array<uint8> | #; o : int64) : float {
     return unsafe(reinterpret<float>(rd_u32(b, o)))
 }
 
+let GGML_BIN_Q8_BLOCK_ELEMS = 32l   //!< a Q8_0 block of a ggml bin: an f16 scale, then this many quants
+let GGML_BIN_Q8_BLOCK_BYTES = 34l
+
+//! `n` elements of a ggml bin tensor at byte `off` into `dst[dst_off..)` as f32: byte-wise, the bin stores its data
+//! unaligned; a Q8_0 element is its block's scale times its quant
+def ggml_bin_read_f32(b : array<uint8> | #; ttype : int; off, n : int64; var dst : array<float>; dst_off : int64) {
+    if (ttype == GGML_TYPE_F32) {
+        for (i in range64(n)) {
+            dst[dst_off + i] = rd_f32(b, off + i * 4l)
+        }
+    } elif (ttype == GGML_TYPE_F16) {
+        for (i in range64(n)) {
+            dst[dst_off + i] = f16_to_f32(rd_u16(b, off + i * 2l))
+        }
+    } else {
+        for (blk in range64(n / GGML_BIN_Q8_BLOCK_ELEMS)) {
+            let at = off + blk * GGML_BIN_Q8_BLOCK_BYTES
+            let scale = f16_to_f32(rd_u16(b, at))
+            for (i in range64(GGML_BIN_Q8_BLOCK_ELEMS)) {
+                dst[dst_off + blk * GGML_BIN_Q8_BLOCK_ELEMS + i] = scale * float(int8(b[at + 2l + i]))
+            }
+        }
+    }
+}
+
+
 def rd_i32(b : array<uint8> | #; o : int64) : int {
     return int(rd_u32(b, o))
 }
diff --git a/modules/dasLLAMA/dasllama/dasllama_env.das b/modules/dasLLAMA/dasllama/dasllama_env.das
index 640d5b9e4e..8b7dfdc5bd 100644
--- a/modules/dasLLAMA/dasllama/dasllama_env.das
+++ b/modules/dasLLAMA/dasllama/dasllama_env.das
@@ -241,7 +241,7 @@ struct public MetalEnv {
     @clarg_doc = "Serve the whisper decoder side (cross-KV; the decode step under wdec_step) on the Metal ASR-decoder driver; 0 pins the CPU decoder."
     wdec : bool = true
 
-    @clarg_doc = "Serve the whisper DECODE STEP on the GPU too (needs wdec). Small decoders (n_text_state under the 1024 floor; set_metal_wdec_step_min_d) keep the CPU rail - the per-dispatch latency floor beats them."
+    @clarg_doc = "Serve the whisper DECODE STEP on the GPU too (needs wdec). Small decoders (n_text_state under the 512 floor; set_metal_wdec_step_min_d) keep the CPU rail - the per-dispatch latency floor beats them."
     wdec_step : bool = true
 
     @clarg_doc = "Fused single-pass decode attention (a head of 64, 96, 128, 256 or 512 on every KV codec; sliding windows, attention sinks, the logit soft cap and a second head class included), on the single row, the speculative verify's rows and the batch; 0 is the A/B rail to the chunked pair."
diff --git a/modules/dasLLAMA/dasllama/dasllama_gemma3v.das b/modules/dasLLAMA/dasllama/dasllama_gemma3v.das
index 309232b7bf..ff43a766ce 100644
--- a/modules/dasLLAMA/dasllama/dasllama_gemma3v.das
+++ b/modules/dasLLAMA/dasllama/dasllama_gemma3v.das
@@ -85,6 +85,8 @@ struct Gemma3vState {
     @scratch @exact_size att : array<float>   // attention score blocks
     @exact_size h : array<float>     // ffn hidden [npos × ff]
     @exact_size pooled : array<float>  // [nout × d]
+    @scratch @exact_size tail : array<float>     // [nout × proj_dim] soft tokens a device chain landed behind its blocks
+    tail_ready : bool                //! `tail` holds this encode's soft tokens: the CPU tail stands down
     @scratch @exact_size xqi : array<int8>    // q8 lane: the requantized GEMM input, grown per site
     @scratch @exact_size xsi : array<float>   // its per-32-block scales
 }
@@ -440,7 +442,7 @@ def stage_gemma3v_tower(path : string) : Gemma3vStaging {
         panic("dasLLAMA: cannot open mmproj gguf '{path}'")
     }
     if (stat(path).size >= GEMMA3V_STAGE_CAP) {
-        panic("dasLLAMA gemma3v: '{path}' is {stat(path).size / 1048576ul} MB - at or past the 1 GiB staged-mint line; serve the f16 mmproj (an f32-widened twin is an oracle artifact, not a serving file)")
+        panic("dasLLAMA gemma3v: '{path}' is {int64(stat(path).size / 1048576ul)} MB - at or past the 1 GiB staged-mint line; serve the f16 mmproj (an f32-widened twin is an oracle artifact, not a serving file)")
     }
     fmap(f) $(var bytes : array<uint8>#) {
         var inscope m <- parse_gguf_meta(bytes)
@@ -712,6 +714,7 @@ def gemma3v_encode(t : Gemma3vTower; var s : Gemma3vState; planes : array<float>
         asr_prof_add("g3v.stem", tp)
     }
     var gpu_served = false
+    s.tail_ready = false
     if (g_g3v_gpu_set) {
         tp = ref_time_ticks()
         gpu_served = invoke(g_g3v_gpu, t, s, npos)
@@ -727,6 +730,15 @@ def gemma3v_encode(t : Gemma3vTower; var s : Gemma3vState; planes : array<float>
             g3v_block(t, s, l, npos)
         }
     }
+    if (gpu_served && s.tail_ready) {   // the device chain ran the tail behind its blocks
+        let n_side = t.image_px / t.patch / t.merge
+        let n_out = n_side * n_side
+        ensure_length(out, n_out * t.proj_dim)
+        unsafe {
+            memcpy(addr(out[0]), addr(s.tail[0]), uint64(n_out * t.proj_dim * 4l))
+        }
+        return n_out
+    }
     tp = ref_time_ticks()
     let nout = g3v_tail(t, s, t.image_px / t.patch, out)
     asr_prof_add("g3v.tail", tp)
diff --git a/modules/dasLLAMA/dasllama/dasllama_gemma4a.das b/modules/dasLLAMA/dasllama/dasllama_gemma4a.das
index 4618943678..3dd7c8b0a5 100644
--- a/modules/dasLLAMA/dasllama/dasllama_gemma4a.das
+++ b/modules/dasLLAMA/dasllama/dasllama_gemma4a.das
@@ -87,7 +87,7 @@ struct Gemma4aEncoder {
     hann : PlaneF = PlaneF()       // [512]: 320 Hann at the front, zeros to 512
     twiddles : PlaneF = PlaneF()   // DFT twiddle matrix [n_fft × (n_bins·2)]
     pos_emb : PlaneF = PlaneF()    // sinusoidal RPE table [13 × d_model]
-    ones : PlaneF = PlaneF()       // [proj_dim] weight for the final weightless RMSNorm
+    ones : PlaneF = PlaneF()       // [mid] weight for the final weightless RMSNorm; its length IS the encoder's own output width (gemma4a_mid_dim)
     blob : PlaneF = PlaneF()
     qblob : PlaneI8 = PlaneI8()
     qscales : PlaneF = PlaneF()
@@ -313,10 +313,12 @@ def load_gemma4a_encoder(path : string) : Gemma4aEncoder {
         let img = image_path_for(path, tag)
         let ts_img = ref_time_ticks()
         var t = Gemma4aEncoder()
-        if (load_image(img, t, tag)) {
+        // an image minted off a widening embedder read as a square one carries the encoder's width as the decoder's: mint again
+        if (load_image(img, t, tag) && t.proj_dim == gemma4a_probe_proj_dim(path)) {
             to_log(LOG_INFO, "dasLLAMA: prepared gemma4a-encoder image mapped in {get_time_usec(ts_img) / 1000} ms - {img}\n")
             return <- t
         }
+        delete t
         var inscope st <- stage_gemma4a_encoder(path)
         var built = Gemma4aEncoder()
         if (cache_via_image_staged(st, built, img, tag)) {
@@ -352,15 +354,17 @@ def gemma4a_probe_proj_dim(path : string) : int64 {
     }
     var dim = 0l
     fmap(f) $(var bytes : array<uint8>#) {
-        if (length(bytes) < 4 || !(int(bytes[0]) == 'G' && int(bytes[1]) == 'G' && int(bytes[2]) == 'U' && int(bytes[3]) == 'F')) {
+        if (long_length(bytes) < 4l || !(int(bytes[0]) == 'G' && int(bytes[1]) == 'G' && int(bytes[2]) == 'U' && int(bytes[3]) == 'F')) {
             return
         }
         var inscope m <- parse_gguf_meta(bytes)
         let out_proj = gguf_find_tensor(m, "a.pre_encode.out.weight")
-        if (out_proj >= 0 && gguf_has(m, "clip.audio.embedding_length")) {
+        let embedder = gguf_find_tensor(m, "mm.a.input_projection.weight")
+        if (out_proj >= 0 && embedder >= 0 && gguf_has(m, "clip.audio.embedding_length")) {
             let d = gguf_int(m, bytes, "clip.audio.embedding_length")
-            if (d > 0l) {
-                dim = m.tensors[out_proj].n_elem / d
+            let mid = d > 0l ? m.tensors[out_proj].n_elem / d : 0l
+            if (mid > 0l) {
+                dim = m.tensors[embedder].n_elem / mid   // the embedder's rows: the decoder's width
             }
         }
     }
@@ -409,8 +413,9 @@ def private g4a_repack_all(var st : Gemma4aStaging) {
     let ff = st.e.n_ff
     let feat = st.e.sub_ch1 * (st.e.n_mel / 4l)
     g4a_repack(st, st.e.inproj_w, feat, d)
-    g4a_repack(st, st.e.outproj_w, d, st.e.proj_dim)
-    g4a_repack(st, st.e.mmproj_w, st.e.proj_dim, st.e.proj_dim)
+    let mid = long_length(st.ones)
+    g4a_repack(st, st.e.outproj_w, d, mid)
+    g4a_repack(st, st.e.mmproj_w, mid, st.e.proj_dim)
     for (l in range64(st.e.n_layer)) {
         let lo = st.layers[l]
         g4a_repack(st, lo.ff_up, d, ff)
@@ -436,6 +441,7 @@ def stage_gemma4a_encoder(path : string) : Gemma4aStaging {
     if (f == null) {
         panic("dasLLAMA gemma4a: cannot open mmproj gguf '{path}'")
     }
+    var mid = 0l   //! the encoder's own output width: the out projection's rows, the weightless norm's, the embedder's columns
     fmap(f) $(var bytes : array<uint8>#) {
         var inscope m <- parse_gguf_meta(bytes)
         let proj = (gguf_has(m, "clip.audio.projector_type")
@@ -462,7 +468,6 @@ def stage_gemma4a_encoder(path : string) : Gemma4aStaging {
         }
         st.e.sub_ch0 = m.tensors[i0].n_elem / 9l            // cin = 1
         st.e.sub_ch1 = m.tensors[i1].n_elem / (9l * st.e.sub_ch0)
-        // proj_dim from the audio multimodal embedder mm.a.input_projection [proj_dim × proj_dim]
         let ip = gguf_find_tensor(m, "mm.a.input_projection.weight")
         if (ip < 0) {
             panic("dasLLAMA gemma4a: missing mm.a.input_projection.weight")
@@ -471,7 +476,9 @@ def stage_gemma4a_encoder(path : string) : Gemma4aStaging {
         if (op < 0) {
             panic("dasLLAMA gemma4a: missing a.pre_encode.out.weight")
         }
-        st.e.proj_dim = m.tensors[op].n_elem / d            // out proj [d × proj_dim]
+        // the encoder's own output width, then the decoder's: the audio multimodal embedder is square on E2B and widens on E4B
+        mid = m.tensors[op].n_elem / d                      // out proj [d × mid]
+        st.e.proj_dim = m.tensors[ip].n_elem / mid          // mm.a.input_projection [mid × proj_dim]
 
         // blob layout: subsample + output first, then per-layer. GEMM fields ride the q cursor
         // on a q8 load (the field then indexes qblob); convs, norms, biases stay on the blob
@@ -484,9 +491,9 @@ def stage_gemma4a_encoder(path : string) : Gemma4aStaging {
         st.e.norm1_w = o; o += st.e.sub_ch1
         let feat = st.e.sub_ch1 * (st.e.n_mel / 4l)          // 32 × 32 = 1024
         st.e.inproj_w = take_cursor(q8, o, qo, d * feat)
-        st.e.outproj_w = take_cursor(q8, o, qo, st.e.proj_dim * d)
-        st.e.outproj_b = o; o += st.e.proj_dim
-        st.e.mmproj_w = take_cursor(q8, o, qo, st.e.proj_dim * st.e.proj_dim)
+        st.e.outproj_w = take_cursor(q8, o, qo, mid * d)
+        st.e.outproj_b = o; o += mid
+        st.e.mmproj_w = take_cursor(q8, o, qo, st.e.proj_dim * mid)
         st.layers |> resize(st.e.n_layer)
         for (l in range64(st.e.n_layer)) {
             var lo = G4aLayer()
@@ -530,9 +537,9 @@ def stage_gemma4a_encoder(path : string) : Gemma4aStaging {
         gguf_read_tensor_f32(m, bytes, "a.conv1d.1.weight", st.blob, st.e.c1_w, st.e.sub_ch1 * st.e.sub_ch0 * 9l)
         gguf_read_tensor_f32(m, bytes, "a.conv1d.1.norm.weight", st.blob, st.e.norm1_w, st.e.sub_ch1)
         g4a_read_gemm(m, bytes, "a.input_projection.weight", st, wscratch, st.e.inproj_w, d * feat)
-        g4a_read_gemm(m, bytes, "a.pre_encode.out.weight", st, wscratch, st.e.outproj_w, st.e.proj_dim * d)
-        gguf_read_tensor_f32(m, bytes, "a.pre_encode.out.bias", st.blob, st.e.outproj_b, st.e.proj_dim)
-        g4a_read_gemm(m, bytes, "mm.a.input_projection.weight", st, wscratch, st.e.mmproj_w, st.e.proj_dim * st.e.proj_dim)
+        g4a_read_gemm(m, bytes, "a.pre_encode.out.weight", st, wscratch, st.e.outproj_w, mid * d)
+        gguf_read_tensor_f32(m, bytes, "a.pre_encode.out.bias", st.blob, st.e.outproj_b, mid)
+        g4a_read_gemm(m, bytes, "mm.a.input_projection.weight", st, wscratch, st.e.mmproj_w, st.e.proj_dim * mid)
         for (l in range64(st.e.n_layer)) {
             let lo = st.layers[l]
             let p = "a.blk.{l}"
@@ -597,8 +604,8 @@ def stage_gemma4a_encoder(path : string) : Gemma4aStaging {
             st.pos_emb[pp * st.e.d_model + i + num_ts] = cos(scaled)
         }
     }
-    st.ones |> resize(st.e.proj_dim)
-    for (i in range64(st.e.proj_dim)) {
+    st.ones |> resize(mid)
+    for (i in range64(mid)) {
         st.ones[i] = 1.0
     }
     return <- st
@@ -1067,21 +1074,26 @@ def gemma4a_encode(enc : Gemma4aEncoder; var st : Gemma4aState) : int64 {
 def private g4a_tail_after_gpu(enc : Gemma4aEncoder; var st : Gemma4aState; npos : int64) : int64
     => st.out_ready ? npos : g4a_projector_tail(enc, st, npos)
 
+//! The encoder's own output width - the out projection's rows and the audio embedder's columns; `proj_dim` is the
+//! embedder's rows, the decoder's width. Equal on E2B, 1536 against 2560 on E4B.
+def gemma4a_mid_dim(enc : Gemma4aEncoder) : int64 => length(enc.ones)
+
 def private g4a_projector_tail(enc : Gemma4aEncoder; var st : Gemma4aState; npos : int64) : int64 {
     let d = enc.d_model
+    let mid = gemma4a_mid_dim(enc)
     let tprof = ref_time_ticks()
-    ensure_length(st.tmp, npos * enc.proj_dim)
+    ensure_length(st.tmp, npos * mid)
     ensure_length(st.out, npos * enc.proj_dim)
-    g4a_mm_rq(enc, st, st.tmp, enc.outproj_w, st.x, d, enc.proj_dim, npos)
-    add_bias_rows(st.tmp, enc.blob, enc.outproj_b, enc.proj_dim, npos)
+    g4a_mm_rq(enc, st, st.tmp, enc.outproj_w, st.x, d, mid, npos)
+    add_bias_rows(st.tmp, enc.blob, enc.outproj_b, mid, npos)
     unsafe {
         var tp = addr(st.tmp[0])
         let wp = plane_at(enc.ones, 0l)
         for (r in range64(npos)) {
-            rmsnorm(tp + r * enc.proj_dim, tp + r * enc.proj_dim, wp, enc.proj_dim, enc.eps)
+            rmsnorm(tp + r * mid, tp + r * mid, wp, mid, enc.eps)
         }
     }
-    g4a_mm_rq(enc, st, st.out, enc.mmproj_w, st.tmp, enc.proj_dim, enc.proj_dim, npos)
+    g4a_mm_rq(enc, st, st.out, enc.mmproj_w, st.tmp, mid, enc.proj_dim, npos)
     asr_prof_add("g4a.enc.proj", tprof)
     return npos
 }
@@ -1150,22 +1162,22 @@ def gemma4a_transcribe(dec : Model; enc : Gemma4aEncoder; var s : Gemma4aAsrSess
                        samples : array<float> | #; blk : block<(seg : TranscribeSegment)>;
                        var detected_lang : string&) : int {
     var tp = ref_time_ticks()
-    var rows : array<float>
+    var inscope rows : array<float>
     let n_audio = gemma4a_encode_all(enc, s.g4st, samples, rows)
     asr_prof_add("g4a.encode", tp)
 
     let dim = dec.config.dim
-    let nl = encode_(dec, "\n", false, false)
+    var inscope nl <- encode_(dec, "\n", false, false)
     // no-think turn: a bare user turn (no system/`<|think|>`) yields a deterministic transcription
     // — the reasoning channel is near-tie-brittle across float engines, so it is disabled here.
-    var head : array<int64>
+    var inscope head : array<int64>
     head |> push(special_id(dec, "<bos>"))
     head |> push(special_id(dec, "<|turn>"))
     head |> push_from(encode_(dec, "user", false, false))
     head |> push_from(nl)
     var inscope tmpl <- arch_chat("gemma4")
     head |> push(special_id(dec, tmpl.audio_pre.parts[0].s))
-    var tail : array<int64>
+    var inscope tail : array<int64>
     tail |> push(special_id(dec, tmpl.audio_post.parts[0].s))
     tail |> push_from(encode_(dec, "Transcribe this audio.", false, false))
     tail |> push(special_id(dec, "<turn|>"))
@@ -1177,26 +1189,21 @@ def gemma4a_transcribe(dec : Model; enc : Gemma4aEncoder; var s : Gemma4aAsrSess
     let n_head = long_length(head)
     let npos = n_head + n_audio + long_length(tail)
     asr_ctx_guard(n_audio, npos, dec.config.seq_len)
-    var embd : array<float>
-    embd |> resize(int(npos * dim))
-    embed_text_rows(dec, head, embd, 0l)
-    for (i in range64(n_audio * dim)) {
-        embd[n_head * dim + i] = rows[i]
-    }
-    embed_text_rows(dec, tail, embd, n_head + n_audio)
+    var inscope embd : array<float>
+    media_body_rows_(dec, s.qctx, head, rows, n_audio, dim, tail, embd)
 
     s.qctx.n_past = 0l   // fresh sequence per transcribe
     tp = ref_time_ticks()
-    eval_embd_(dec, s.qctx, embd, npos)
+    eval_embd_body_(dec, s.qctx, embd, npos, 0l, 0l, int2(0))
     asr_prof_add("g4a.prefill", tp)
 
     let turn_end = special_id(dec, "<turn|>")
     let eos = special_id(dec, "<eos>")
     let max_new = dec.config.seq_len - npos - 1l
-    var one : array<int64>
+    var inscope one : array<int64>
     one |> resize(1)
-    var toks : array<int>
-    var raw : array<string>
+    var inscope toks : array<int>
+    var inscope raw : array<string>
     toks |> reserve(512)
     raw |> reserve(512)
     tp = ref_time_ticks()
@@ -1221,7 +1228,7 @@ def gemma4a_transcribe(dec : Model; enc : Gemma4aEncoder; var s : Gemma4aAsrSess
     if (mark >= 0) {
         text = slice(full, mark + length("<channel|>"), length(full))
     }
-    var seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE,
+    var inscope seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE,
         text = strip(text))
     seg.tokens := toks
     detected_lang = "en"
diff --git a/modules/dasLLAMA/dasllama/dasllama_gemma4v.das b/modules/dasLLAMA/dasllama/dasllama_gemma4v.das
index f154014ecc..02f2f06e7a 100644
--- a/modules/dasLLAMA/dasllama/dasllama_gemma4v.das
+++ b/modules/dasLLAMA/dasllama/dasllama_gemma4v.das
@@ -103,6 +103,8 @@ struct Gemma4vState {
     @scratch pos_x : array<int64>; @scratch pos_y : array<int64>   // the grid's patch columns / rows
     grid_w : int64       // the grid the tables were built for (0 = none yet)
     grid_h : int64
+    @scratch @exact_size tail : array<float>   // [nout × proj_dim] soft tokens a device chain landed behind its blocks
+    tail_ready : bool    //! `tail` holds this encode's soft tokens: the CPU tail stands down
 }
 
 // the tower owns exactly one thing — its image backing. Every plane borrows.
@@ -221,10 +223,14 @@ typedef Gemma4vGpuServesFn = function<() : bool>
 var private g_g4v_gpu : Gemma4vGpuBlocksFn
 var private g_g4v_gpu_serves : Gemma4vGpuServesFn
 var private g_g4v_gpu_set = false
+var private g_g4v_gpu_stem = false   //! the registered chain runs the stem's patch conv and position adds itself, off `s.x0`
 
-def register_gemma4v_gpu(fn : Gemma4vGpuBlocksFn; serves : Gemma4vGpuServesFn) {
+//! `stem` says the chain takes the stem's columns (`s.x0`) and runs the patch conv and the position adds itself; a
+//! chain registered without it is handed the finished residual stream in `s.x`.
+def register_gemma4v_gpu(fn : Gemma4vGpuBlocksFn; serves : Gemma4vGpuServesFn; stem : bool = false) {
     g_g4v_gpu = fn
     g_g4v_gpu_serves = serves
+    g_g4v_gpu_stem = stem
     g_g4v_gpu_set = true
 }
 
@@ -409,7 +415,7 @@ def stage_gemma4v_tower(path : string) : Gemma4vStaging {
     // the staged mint holds source + image at once; past the line a carrier streams like a decoder,
     // and this tower has no streamed mint — the shipped vision mmprojs sit under it (E2B bf16 0.99 GB)
     if (stat(path).size >= GEMMA4V_STAGE_CAP) {
-        panic("dasLLAMA gemma4v: '{path}' is {stat(path).size / 1048576ul} MB - at or past the 1 GiB staged-mint line; serve the bf16 mmproj (an f32-widened twin is an oracle artifact, not a serving file)")
+        panic("dasLLAMA gemma4v: '{path}' is {int64(stat(path).size / 1048576ul)} MB - at or past the 1 GiB staged-mint line; serve the bf16 mmproj (an f32-widened twin is an oracle artifact, not a serving file)")
     }
     fmap(f) $(var bytes : array<uint8>#) {
         var inscope m <- parse_gguf_meta(bytes)
@@ -684,9 +690,8 @@ def private g4v_block(t : Gemma4vTower; var s : Gemma4vState; l, npos : int64) {
     asr_prof_add("g4v.norm", tp)
 }
 
-// the stem: im2col → x·2−1 → patch conv → x/y position-table adds, leaving the residual stream in
-// s.x (npos rows); sizes every block buffer for this canvas
-def private g4v_stem(t : Gemma4vTower; var s : Gemma4vState; planes : array<float>; w, h, n_cols : int64) : int64 {
+// the stem's columns: im2col → x·2−1 into s.x0 (npos rows); sizes every block buffer for this canvas
+def private g4v_stem_cols(t : Gemma4vTower; var s : Gemma4vState; planes : array<float>; w, h : int64) : int64 {
     let d = t.n_embd
     let npos = im2col_rgb_patches(planes, w, h, t.patch, s.x0)
     // inp_raw_scaled: pixels [0, 1] -> [-1, 1] ahead of the conv
@@ -704,6 +709,13 @@ def private g4v_stem(t : Gemma4vTower; var s : Gemma4vState; planes : array<floa
     ensure_length(s.vv, npos * d)
     ensure_length(s.hg, npos * t.n_ff)
     ensure_length(s.hu, npos * t.n_ff)
+    return npos
+}
+
+// the stem's finish: the patch conv over the columns and the x/y position-table adds, leaving the residual stream in
+// s.x - a device chain runs both itself off s.x0
+def private g4v_stem_finish(t : Gemma4vTower; var s : Gemma4vState; npos, n_cols : int64) {
+    let d = t.n_embd
     mm_plane_b(s.x, t.patch_bf16, t.wblob, t.blob, t.patch_w, s.x0, t.patch_dim, d, npos)
     unsafe {
         var xp = addr(s.x[0])
@@ -717,7 +729,6 @@ def private g4v_stem(t : Gemma4vTower; var s : Gemma4vState; planes : array<floa
             }
         }
     }
-    return npos
 }
 
 // the tail: Gemma4VisionPooler (merge×merge mean, ×√d), the std guard, then the
@@ -765,18 +776,40 @@ def gemma4v_encode(t : Gemma4vTower; var s : Gemma4vState; planes : array<float>
     let n_rows = h / t.patch
     dispatch_phase_encode(n_cols * n_rows)
     var tp = ref_time_ticks()
-    let npos = g4v_stem(t, s, planes, w, h, n_cols)
+    let npos = g4v_stem_cols(t, s, planes, w, h)
     g4v_rope_tables(t, s, n_cols, n_rows)
     asr_prof_add("g4v.stem", tp)
     var gpu_served = false
+    let finished = !g_g4v_gpu_set || !g_g4v_gpu_stem
+    if (finished) {
+        tp = ref_time_ticks()
+        g4v_stem_finish(t, s, npos, n_cols)
+        asr_prof_add("g4v.stem", tp)
+    }
+    s.tail_ready = false
     if (g_g4v_gpu_set) {
+        tp = ref_time_ticks()
         gpu_served = invoke(g_g4v_gpu, t, s, npos)
+        asr_prof_add("g4v.gpu", tp)
     }
     if (!gpu_served) {
+        if (!finished) {
+            tp = ref_time_ticks()
+            g4v_stem_finish(t, s, npos, n_cols)
+            asr_prof_add("g4v.stem", tp)
+        }
         for (l in range64(t.n_layer)) {
             g4v_block(t, s, l, npos)
         }
     }
+    if (gpu_served && s.tail_ready) {   // the device chain ran the tail behind its blocks
+        let n_out = (n_cols / t.merge) * (n_rows / t.merge)
+        ensure_length(out, n_out * t.proj_dim)
+        unsafe {
+            memcpy(addr(out[0]), addr(s.tail[0]), uint64(n_out * t.proj_dim * 4l))
+        }
+        return n_out
+    }
     tp = ref_time_ticks()
     let nout = g4v_tail(t, s, n_cols, n_rows, out)
     asr_prof_add("g4v.tail", tp)
diff --git a/modules/dasLLAMA/dasllama/dasllama_gguf.das b/modules/dasLLAMA/dasllama/dasllama_gguf.das
index 19632b4ba8..97cbf49ad3 100644
--- a/modules/dasLLAMA/dasllama/dasllama_gguf.das
+++ b/modules/dasLLAMA/dasllama/dasllama_gguf.das
@@ -65,6 +65,14 @@ def ggml_type_bytes(gt : int; n : int64) : int64 {
     return 0l
 }
 
+//! the bytes a tensor of ggml type `ttype` takes in a whisper-style bin: f32, f16, or Q8_0 blocks
+def ggml_bin_tensor_bytes(ttype : int; n_elem : int64) : int64 {
+    if (ttype != GGML_TYPE_F32 && ttype != GGML_TYPE_F16 && ttype != GGML_TYPE_Q8_0) {
+        panic("dasLLAMA: ggml bin tensor type {ttype} - f32, f16 and q8_0 tensors load")
+    }
+    return ggml_type_bytes(ttype, n_elem)
+}
+
 //! Bytes `n` weights of a kq format take on disk (the ggml block sizes, so a 32-block format
 //! answers per 32) - what a device plane is measured against; q8 counts its Q8_0 blocks.
 def kq_disk_bytes(f : KqFmt; n : int64) : int64 => ggml_type_bytes(kq_ggml_type(f), n)
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_asr_dec.das b/modules/dasLLAMA/dasllama/dasllama_metal_asr_dec.das
index ecedc4de4c..6501efb006 100644
--- a/modules/dasLLAMA/dasllama/dasllama_metal_asr_dec.das
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_asr_dec.das
@@ -29,7 +29,9 @@ var private g_wd_failed = false
 var private g_wd_pool : MetalBufferPool
 var private g_wd_env = true
 var private g_wd_step_env = true    // the decode-step half (DASLLAMA_METAL_WDEC_STEP); windows capture it
-var private g_wd_step_min_d = 1024l   // the step's serving floor (measured: d=1280 wins 1.6x, d=384 loses)
+//! The text width the decode step serves from: at 384 (tiny) the device step is slower than the CPU's, from 512 (base) up it is faster.
+let METAL_WDEC_STEP_MIN_D = 512l
+var private g_wd_step_min_d = METAL_WDEC_STEP_MIN_D
 // the attached decoder, keyed on the dq plane (base, length): ONE live whisper decoder per
 // process is the serving contract — a key mismatch re-attaches; tests switching models call
 // metal_wdec_shutdown between them (address reuse after an unmap could alias the key)
@@ -115,7 +117,54 @@ def private wd_decline(why : MetalWdecDecline) : bool {
     return false
 }
 
+var private g_wd_pend_uid = 0ul           //!< the state whose cross-KV layouts wait on the device, unread
+var private g_wd_pend_bytes = 0ul         //!< their size a plane; 0 = nothing waits
+var private g_wd_pend_kx : MetalBuffer?
+var private g_wd_pend_vx : MetalBuffer?
+var private g_wd_dropped : table<uint64>  //!< the states whose waiting layouts were lost unread; a state leaves it at its next window
+var private g_wd_uid_next = 1ul
+
+//! the driver's identity for a decoder state, minted at its first window: a state re-created at the same address inherits nothing
+def private wd_uid(var ds : DecoderState) : uint64 {
+    if (ds.gpu_uid == 0ul) {
+        ds.gpu_uid = g_wd_uid_next++
+    }
+    return ds.gpu_uid
+}
+
+def private wd_pend_release {
+    pool_release(g_wd_pool, g_wd_pend_kx, g_wd_pend_bytes)
+    pool_release(g_wd_pool, g_wd_pend_vx, g_wd_pend_bytes)
+    g_wd_pend_kx = null
+    g_wd_pend_vx = null
+    g_wd_pend_bytes = 0ul
+}
+
+//! the waiting cross-KV layouts of `ds`, where they are its own, landed in its `kx` / `vx`: the CPU chain is about to read them
+[cold_path]
+def private wd_flush_cross_kv(var ds : DecoderState) {
+    if (g_wd_pend_bytes == 0ul || g_wd_pend_uid != ds.gpu_uid) {
+        return
+    }
+    unsafe {
+        memcpy(addr(ds.kx[0]), metal_buffer_contents(g_wd_pend_kx), g_wd_pend_bytes)
+        memcpy(addr(ds.vx[0]), metal_buffer_contents(g_wd_pend_vx), g_wd_pend_bytes)
+    }
+    wd_pend_release()
+}
+
+//! the waiting layouts lost unread (another window's about to take their place, or the driver released): the owner is marked,
+//! and its next decode step panics until it starts a window of its own
+[cold_path]
+def private wd_drop_pending {
+    if (g_wd_pend_bytes > 0ul) {
+        g_wd_dropped |> insert(g_wd_pend_uid)
+        wd_pend_release()
+    }
+}
+
 def private wd_release_all {
+    wd_drop_pending()
     release_handles(g_wd_mblob, g_wd_bkxr, g_wd_bvxr, g_wd_bkc, g_wd_bvc, g_wd_sx)
     release_handles(g_wd_sxb, g_wd_sxb2, g_wd_sq, g_wd_sk, g_wd_sv, g_wd_sh)
     release_handles(g_wd_slog, g_wd_bpms, g_wd_bpy)
@@ -230,6 +279,8 @@ def private wdec_attach(w : WhisperModel) : bool {
 [hot_path]
 def private metal_whisper_cross_kv(w : WhisperModel; var ds : DecoderState; enc_out : array<float>) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
     g_wd_window_live = false   // whatever happens below, the previous window is over
+    wd_drop_pending()
+    g_wd_dropped |> erase(wd_uid(ds))   // this state starts a window of its own, on either chain
     if (!g_wd_env) {
         return wd_decline(MetalWdecDecline.knob)
     }
@@ -258,6 +309,7 @@ def private metal_whisper_cross_kv(w : WhisperModel; var ds : DecoderState; enc_
     var btmp = pool_acquire(g_wd_pool, g_dev, bytes_rows)
     var bkx = pool_acquire(g_wd_pool, g_dev, bytes_x)
     var bvx = pool_acquire(g_wd_pool, g_dev, bytes_x)
+    var bxh = pf_q8_mm_half() ? pool_acquire(g_wd_pool, g_dev, bytes_rows / 2ul) : null
     upload_rows_padded(bx, unsafe(addr(enc_out[0])), ta, mp, d)   // the pad outputs go unread; the zero guards stale-Inf pool reuse
     var u_d = uniform_u32(uint(d))
     var u_hs = uniform_u32(uint(hs))
@@ -271,11 +323,14 @@ def private metal_whisper_cross_kv(w : WhisperModel; var ds : DecoderState; enc_
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
         for (l in range64(nl)) {
             let lo = dec_layer_offsets(w, l)
-            enc_gemm_mm_b(enc, g_wd_mblob, g_wd_boffs[l * WD_MATS + 5l], bx, btmp, 0ul, u_d, u_d, mp, d)
+            if (bxh != null && l == 0l) {   // one half panel serves every layer's two GEMMs: they all read the encoder rows
+                enc_cvt_half(enc, bx, bxh, mp * d)
+            }
+            pf_enc_q8_mm(enc, g_wd_mblob, g_wd_boffs[l * WD_MATS + 5l], bx, bxh, btmp, u_d, u_d, mp, d, d)
             // kx: the pre-scaled CPU layout (the ds.kx readback); kxr: the unscaled resident twin
             enc_cross_kx(enc, btmp, bkx, uint64(l * d * ta * 4l), u_d, u_hs, u_ta, u_kscale, u_tot, d * ta)
             enc_cross_vx_h(enc, btmp, 0ul, g_wd_bkxr, uint64(l * d * ta * 2l), bblobf, 0ul, u_d, u_hs, u_ta, u_t0, u_ta, u_h0, u_tot, d * ta)
-            enc_gemm_mm_b(enc, g_wd_mblob, g_wd_boffs[l * WD_MATS + 6l], bx, btmp, 0ul, u_d, u_d, mp, d)
+            pf_enc_q8_mm(enc, g_wd_mblob, g_wd_boffs[l * WD_MATS + 6l], bx, bxh, btmp, u_d, u_d, mp, d, d)
             // cv bias folds into both shuffles: the f32 readback (ds.vx) and the f16 resident
             enc_cross_vx(enc, btmp, 0ul, bvx, uint64(l * d * ta * 4l), bblobf, uint64(lo.cv_b * 4l), u_d, u_hs, u_ta, u_t0, u_ta, u_h1, u_tot, d * ta)
             enc_cross_vx_h(enc, btmp, 0ul, g_wd_bvxr, uint64(l * d * ta * 2l), bblobf, uint64(lo.cv_b * 4l), u_d, u_hs, u_ta, u_t0, u_ta, u_h1, u_tot, d * ta)
@@ -283,10 +338,6 @@ def private metal_whisper_cross_kv(w : WhisperModel; var ds : DecoderState; enc_
     }
     var served = false
     if (ran) {
-        unsafe {
-            memcpy(addr(ds.kx[0]), metal_buffer_contents(bkx), bytes_x)
-            memcpy(addr(ds.vx[0]), metal_buffer_contents(bvx), bytes_x)
-        }
         g_wdec_windows++
         g_wd_window_key = intptr(unsafe(addr(ds)))
         g_wd_window_live = true
@@ -299,10 +350,26 @@ def private metal_whisper_cross_kv(w : WhisperModel; var ds : DecoderState; enc_
         }
         served = true
     }
+    if (served && g_wd_window_step) {   // the device step reads the resident twins: the CPU layouts wait, read back only at a decline
+        g_wd_pend_uid = ds.gpu_uid
+        g_wd_pend_bytes = bytes_x
+        g_wd_pend_kx = bkx
+        g_wd_pend_vx = bvx
+    } else {
+        if (served) {
+            unsafe {
+                memcpy(addr(ds.kx[0]), metal_buffer_contents(bkx), bytes_x)
+                memcpy(addr(ds.vx[0]), metal_buffer_contents(bvx), bytes_x)
+            }
+        }
+        pool_release(g_wd_pool, bkx, bytes_x)
+        pool_release(g_wd_pool, bvx, bytes_x)
+    }
     pool_release(g_wd_pool, bx, bytes_rows)
     pool_release(g_wd_pool, btmp, bytes_rows)
-    pool_release(g_wd_pool, bkx, bytes_x)
-    pool_release(g_wd_pool, bvx, bytes_x)
+    if (bxh != null) {
+        pool_release(g_wd_pool, bxh, bytes_rows / 2ul)
+    }
     pool_release(g_upool, u_d, 4ul)
     pool_release(g_upool, u_hs, 4ul)
     pool_release(g_upool, u_ta, 4ul)
@@ -344,7 +411,11 @@ def private wd_mm(enc : MetalComputeEncoder?; boff : uint64; bx, by : MetalBuffe
 // logits) and the full-vocab logits readback — the CPU filter/sampler stays the parity anchor.
 [hot_path]
 def private metal_whisper_decode(w : WhisperModel; var ds : DecoderState; toks : int const?; n : int64) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
+    if (ds.gpu_uid != 0ul && key_exists(g_wd_dropped, ds.gpu_uid)) {
+        panic("dasLLAMA wdec: this decoder window's cross-attention memory was lost before it was read back - another state's window or a driver release took its device planes; ONE live decoder window per process, and a state decodes only a window it started after the loss")
+    }
     if (!g_wd_window_live || !g_wd_window_step || g_wd_window_key != intptr(unsafe(addr(ds)))) {
+        wd_flush_cross_kv(ds)
         // an evicted GPU-decoded window: the CPU chain would read kcache rows the GPU owns
         if (ds.gpu_kv_gen != 0l && ds.n_past > 0l) {
             panic("dasLLAMA wdec: the GPU decoder window was evicted mid-window - ONE live decoder window per process (a second DecoderState may not interleave whisper_cross_kv/whisper_decode_batch)")
@@ -354,6 +425,7 @@ def private metal_whisper_decode(w : WhisperModel; var ds : DecoderState; toks :
     if (n > WD_ROW_CAP) {
         if (ds.n_past == 0l) {   // first batch: nothing GPU-owned yet — release the claim, the CPU serves the window
             g_wd_window_live = false
+            wd_flush_cross_kv(ds)
             return false
         }
         panic("dasLLAMA wdec: decode batch of {n} exceeds the {WD_ROW_CAP}-row step cap mid-window")
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_common.das b/modules/dasLLAMA/dasllama/dasllama_metal_common.das
index 2091ec220d..fc6573402f 100644
--- a/modules/dasLLAMA/dasllama/dasllama_metal_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_common.das
@@ -76,6 +76,8 @@ var g_tower_rows = 0l
 var g_tower_blocks = 0l
 var g_tower_convs = 0l                       // conv-frontend chunks served on the GPU
 var g_tower_f16_encodes = 0l                 // encodes whose GEMMs rode the f16-W shadow route
+var g_tower_mels = 0l                        // whisper-preprocessor mels served on the GPU
+var g_tower_tail_encodes = 0l                // whisper-class encodes whose projector tail ran behind the blocks
 var g_tower_declines : DeclineCounter
 
 // the whisper ASR-decoder driver's counters (dasllama_metal_asr_dec; counting home here)
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_prefill.das b/modules/dasLLAMA/dasllama/dasllama_metal_prefill.das
index ec56abf679..c6d3eecd39 100644
--- a/modules/dasLLAMA/dasllama/dasllama_metal_prefill.das
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_prefill.das
@@ -4271,6 +4271,158 @@ class MetalG4aLogMel {
     }
 }
 
+struct TwRowsArgs {
+    width : uint    //!< the OUTPUT row's width
+    total : uint    //!< output elements
+}
+
+//! The whisper-class projector tails' pair pool: y [rows x width] the mean of x's row pairs [2 rows x width].
+[metal_dispatch(name = "enc_tw_pool2", pso = "g_pf_pso_tw_pool2", tg = 64, grid = "total/64", params = "total : int64")]
+class MetalTwPool2 {
+    @ssbo @binding = 0 @role = "read" x : array<float>
+    @ssbo @binding = 1 @role = "write" y : array<float>
+    @uniform @binding = 2 ka : TwRowsArgs
+
+    [metal_kernel(name="metal_tw_pool2_msl")]
+    def metal_tw_pool2 {
+        let gid = gl_GlobalInvocationID.x
+        if (gid >= ka.total) {
+            return
+        }
+        let at = (gid / ka.width) * 2u * ka.width + gid % ka.width
+        y[gid] = 0.5 * (x[at] + x[at + ka.width])
+    }
+}
+
+struct TwAffineArgs {
+    width : uint    //!< a row's width
+    total : uint    //!< elements
+    scale : float
+}
+
+//! A vision tail's row standardize, in place: x = (x * scale - b[c]) * m[c] over rows of `width`.
+[metal_dispatch(name = "enc_tw_affine_rows", pso = "g_pf_pso_tw_affine", tg = 64, grid = "total/64", params = "total : int64")]
+class MetalTwAffineRows {
+    @ssbo @binding = 0 @role = "readwrite" x : array<float>
+    @ssbo @binding = 1 @role = "read" b : array<float>
+    @ssbo @binding = 2 @role = "read" m : array<float>
+    @uniform @binding = 3 ka : TwAffineArgs
+
+    [metal_kernel(name="metal_tw_affine_rows_msl")]
+    def metal_tw_affine_rows {
+        let gid = gl_GlobalInvocationID.x
+        if (gid >= ka.total) {
+            return
+        }
+        let c = gid % ka.width
+        x[gid] = (x[gid] * ka.scale - b[c]) * m[c]
+    }
+}
+
+struct TwPool2dArgs {
+    width : uint    //!< a row's width
+    gw : uint       //!< the source grid's width, in rows
+    k : uint        //!< the pool's side
+    ow : uint       //!< the pooled grid's width
+    total : uint    //!< output elements
+}
+
+//! A vision tail's mean pool: y [oh*ow x width] the mean of each k x k block of the row grid x [gh*gw x width].
+[metal_dispatch(name = "enc_tw_pool2d", pso = "g_pf_pso_tw_pool2d", tg = 64, grid = "total/64", params = "total : int64")]
+class MetalTwPool2d {
+    @ssbo @binding = 0 @role = "read" x : array<float>
+    @ssbo @binding = 1 @role = "write" y : array<float>
+    @uniform @binding = 2 ka : TwPool2dArgs
+
+    [metal_kernel(name="metal_tw_pool2d_msl")]
+    def metal_tw_pool2d {
+        let gid = gl_GlobalInvocationID.x
+        if (gid >= ka.total) {
+            return
+        }
+        let o = gid / ka.width
+        let c = gid % ka.width
+        let oy = o / ka.ow
+        let ox = o % ka.ow
+        var sum = 0.0
+        var dy = 0u
+        while (dy < ka.k) {
+            var dx = 0u
+            while (dx < ka.k) {
+                sum += x[((oy * ka.k + dy) * ka.gw + ox * ka.k + dx) * ka.width + c]
+                dx++
+            }
+            dy++
+        }
+        y[gid] = sum / float(ka.k * ka.k)
+    }
+}
+
+//! The ultravox projector's gate: y [rows x width] = silu(second half of x's row) * its first half, x [rows x 2 width].
+[metal_dispatch(name = "enc_tw_swiglu_rows", pso = "g_pf_pso_tw_swiglu_rows", tg = 64, grid = "total/64", params = "total : int64")]
+class MetalTwSwigluRows {
+    @ssbo @binding = 0 @role = "read" x : array<float>
+    @ssbo @binding = 1 @role = "write" y : array<float>
+    @uniform @binding = 2 ka : TwRowsArgs
+
+    [metal_kernel(name="metal_tw_swiglu_rows_msl")]
+    def metal_tw_swiglu_rows {
+        let gid = gl_GlobalInvocationID.x
+        if (gid >= ka.total) {
+            return
+        }
+        let at = (gid / ka.width) * 2u * ka.width + gid % ka.width
+        let g = x[at + ka.width]
+        y[gid] = (g / (1.0 + exp(-g))) * x[at]
+    }
+}
+
+struct CnMelNormArgs {
+    nmel : uint
+    nlen : uint     //!< frames the mel holds
+    valid : uint    //!< frames of real audio: the statistics' span, the rows past it zeroed
+    mfloor : float
+}
+
+//! Canary's log and per-feature normalization over the mel GEMM's sums [rows x nmel], in place, one thread a mel
+//! feature: log(sum + floor), the mean and the Bessel deviation over the valid frames, every valid frame normalized
+//! and the frames past them zero - the CPU form's three passes.
+[metal_dispatch(name = "enc_cn_melnorm", pso = "g_pf_pso_cn_melnorm", tg = 64, grid = "nmel/64", params = "nmel : int64")]
+class MetalCnMelNorm {
+    @ssbo @binding = 0 @role = "readwrite" mel : array<float>   //!< [rows x nmel]
+    @uniform @binding = 1 ka : CnMelNormArgs
+
+    [metal_kernel(name="metal_cn_melnorm_msl")]
+    def metal_cn_melnorm {
+        let j = gl_GlobalInvocationID.x
+        if (j >= ka.nmel) {
+            return
+        }
+        var sum = 0.0
+        var i = 0u
+        while (i < ka.valid) {
+            let v = log(mel[i * ka.nmel + j] + ka.mfloor)
+            mel[i * ka.nmel + j] = v
+            sum += v
+            i++
+        }
+        let mean = sum / float(max(ka.valid, 1u))
+        var sq = 0.0
+        i = 0u
+        while (i < ka.valid) {
+            let dv = mel[i * ka.nmel + j] - mean
+            sq += dv * dv
+            i++
+        }
+        let denom = sqrt(sq / max(float(ka.valid) - 1.0, 1.0)) + 1e-5
+        i = 0u
+        while (i < ka.nlen) {
+            mel[i * ka.nmel + j] = i < ka.valid ? (mel[i * ka.nmel + j] - mean) / denom : 0.0
+            i++
+        }
+    }
+}
+
 //! The subsample conv's LayerNorm(channels, weight-only) + ReLU: one thread per row —
 //! mean/variance over ``dim`` at ``ldin`` stride, compact ``dim``-wide rows out at ``ldout``.
 [metal_dispatch(name = "enc_g4a_lnrelu", pso = "g_pf_pso_g4a_lnrelu", tg = 64, grid = "nrows/64", params = "nrows : int64")]
@@ -4477,6 +4629,11 @@ var private g_pf_pso_pk_dw : MetalComputePipeline?       //!< the same on parake
 var private g_pf_pso_pk_conv0 : MetalComputePipeline?    //!< the parakeet front: the first conv with its ReLU
 var private g_pf_pso_pk_dw2d : MetalComputePipeline?     //!< its depthwise stride-2 conv
 var private g_pf_pso_pk_xf : MetalComputePipeline?       //!< its feature rows for the pre-projection
+var private g_pf_pso_cn_melnorm : MetalComputePipeline?  //!< canary's log and per-feature normalization over the mel
+var private g_pf_pso_tw_pool2 : MetalComputePipeline?    //!< the whisper-class projector tails' pair pool
+var private g_pf_pso_tw_swiglu_rows : MetalComputePipeline?   //!< the ultravox projector's row-split gate
+var private g_pf_pso_tw_pool2d : MetalComputePipeline?   //!< a vision tail's k x k mean pool over the row grid
+var private g_pf_pso_tw_affine : MetalComputePipeline?   //!< a vision tail's scale and standardize over rows
 var private g_pf_pso_bias_relu : MetalComputePipeline?   //!< a 1x1 conv's bias and ReLU over its GEMM's rows
 var private g_pf_pso_g4a_attn : MetalComputePipeline?    //!< the gemma4a sliding-window RPE attention
 var private g_pf_pso_g4a_glu : MetalComputePipeline?     //!< its conv-module GLU halves
@@ -4906,6 +5063,8 @@ def public metal_prefill_shutdown {
     release_handles(g_pf_pso_twr_flash, g_pf_pso_twr_kvhc, g_pf_pso_twr_win)
     release_handles(g_pf_pso_fc_pack, g_pf_pso_fc_softmax, g_pf_pso_fc_unpack, g_pf_pso_cn_dw, g_pf_pso_pk_dw)
     release_handles(g_pf_pso_pk_conv0, g_pf_pso_pk_dw2d, g_pf_pso_pk_xf, g_pf_pso_bias_relu)
+    release_handles(g_pf_pso_cn_melnorm, g_pf_pso_tw_pool2, g_pf_pso_tw_swiglu_rows, g_pf_pso_tw_pool2d)
+    release_handle(g_pf_pso_tw_affine)
     release_handles(g_pf_pso_g4a_attn, g_pf_pso_g4a_glu, g_pf_pso_g4a_dw, g_pf_pso_g4a_silu, g_pf_pso_g4a_axpy)
     release_handles(g_pf_pso_g4a_mag, g_pf_pso_g4a_logmel, g_pf_pso_g4a_lnrelu)
     release_handles(g_pf_pso_q3a_shuffle, g_pf_pso_q3a_finish, g_pf_pso_q3a_pow, g_pf_pso_q3a_logmel_t)
@@ -5088,6 +5247,11 @@ def private metal_prefill_init : bool {   // nolint:STYLE038 — flat one-compil
     g_pf_pso_pk_conv0 = compile_stamp(metal_pk_conv0_msl, ok)
     g_pf_pso_pk_dw2d = compile_stamp(metal_pk_dw2d_msl, ok)
     g_pf_pso_pk_xf = compile_stamp(metal_pk_xf_msl, ok)
+    g_pf_pso_cn_melnorm = compile_stamp(metal_cn_melnorm_msl, ok)
+    g_pf_pso_tw_pool2 = compile_stamp(metal_tw_pool2_msl, ok)
+    g_pf_pso_tw_swiglu_rows = compile_stamp(metal_tw_swiglu_rows_msl, ok)
+    g_pf_pso_tw_pool2d = compile_stamp(metal_tw_pool2d_msl, ok)
+    g_pf_pso_tw_affine = compile_stamp(metal_tw_affine_rows_msl, ok)
     g_pf_pso_bias_relu = compile_stamp(metal_bias_relu_rows_msl, ok)
     g_pf_pso_g4a_attn = compile_stamp(metal_g4a_attn_msl, ok)
     g_pf_pso_g4a_glu = compile_stamp(metal_g4a_glu_msl, ok)
@@ -5387,6 +5551,12 @@ def pf_fc_ready(tap_major : bool) : bool => psos_ready(fixed_array(g_pf_pso_fc_p
 //! The parakeet subsample front's kernels compiled - the whole-encode driver's extra device gate.
 def pf_pk_front_ready() : bool => psos_ready(fixed_array(g_pf_pso_pk_conv0, g_pf_pso_pk_dw2d, g_pf_pso_pk_xf, g_pf_pso_bias_relu, g_pf_pso_addbias))
 
+//! The canary front's kernels compiled - the parakeet front's, the spectrum's and the mel normalization.
+def pf_cn_front_ready() : bool => pf_pk_front_ready() && psos_ready(fixed_array(g_pf_pso_cn_melnorm, g_pf_pso_q3a_pow))
+
+//! The projector tails' row kernels compiled: the whisper-class pair pool and gate, the vision grid pool.
+def pf_tw_tail_ready() : bool => psos_ready(fixed_array(g_pf_pso_tw_pool2, g_pf_pso_tw_swiglu_rows, g_pf_pso_tw_pool2d, g_pf_pso_tw_affine))
+
 //! The gemma4a Conformer kernel set compiled — its tower driver's device gate.
 def pf_g4a_ready() : bool => psos_ready(fixed_array(g_pf_pso_g4a_attn, g_pf_pso_g4a_glu, g_pf_pso_g4a_dw, g_pf_pso_g4a_silu, g_pf_pso_g4a_axpy))
 
@@ -5824,6 +5994,16 @@ def private enc_gemm_mm(enc : MetalComputeEncoder?; bwblob : MetalBuffer?; wboff
     }
 }
 
+//! whether a GEMM through `pf_enc_q8_mm` reads a half activation panel on this box: the caller converts one a panel
+def pf_q8_mm_half() : bool => (g_pf_mm_tensor && g_pf_pso_mm_th != null) || (g_pf_tensor_ok && g_pf_pso_hmm_th != null)
+
+//! One q8 GEMM over a 34-byte-block blob on the prefill ladder, for a driver outside this file: `mp` rows padded to 32,
+//! no GEMV tail; `bxh` is the caller's half twin of `bx`, null where `pf_q8_mm_half` says none is read.
+[arch(at="../ARCHITECTURE_GPU_PREFILL.md#prefill-gemm-ladder")]
+def pf_enc_q8_mm(enc : MetalComputeEncoder?; bwblob : MetalBuffer?; wboff : uint64; bx, bxh, by, bk, bn : MetalBuffer?; mp, d, kdim : int64) {
+    enc_gemm_mm(enc, bwblob, wboff, bx, by, bk, bn, mp, d, 0ul, kdim, 0l, bxh)
+}
+
 //! kdim feeds the tall/remainder split's X stride; kdim-less callers stay whole-dispatch 32-tile
 [arch(at="../ARCHITECTURE_GPU_PREFILL.md#prefill-gemm-ladder")]
 def pf_enc_bf16_mm(enc : MetalComputeEncoder?; bw : MetalBuffer?; wboff : uint64;
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_tower.das b/modules/dasLLAMA/dasllama/dasllama_metal_tower.das
index 1df697cf93..3985e7f79f 100644
--- a/modules/dasLLAMA/dasllama/dasllama_metal_tower.das
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_tower.das
@@ -49,6 +49,7 @@ var private g_tw_pool : MetalBufferPool
 var private g_tw_env_tower = true
 var private g_tw_env_tower_f16 = true
 var private g_tw_env_tower_flash = true
+var private g_tw_tail = true              // the whisper-class projector tail rides the device behind the blocks
 var private g_tw_ones : MetalBuffer?      // [TW_ONES_DIM] ones — the weightless-rms weight bind
 let private TW_ONES_DIM = 8192
 
@@ -91,9 +92,23 @@ def set_metal_tower_flash(on : bool) {
     g_tw_env_tower_flash = on
 }
 
+//! The whisper-class projector tail's A/B seat: off, the tail seat serves the blocks alone and the CPU tail reads their rows.
+def set_metal_tower_tail(on : bool) {
+    g_tw_tail = on
+}
+
+//! The tail lever as it stands, for a cell that puts it back where it found it.
+def metal_tower_tail_knob() : bool => g_tw_tail
+
 //! Encodes whose block/merger GEMMs rode the f16-W shadow route — the engage witness.
 def metal_tower_f16_encodes() : int64 => g_tower_f16_encodes
 
+//! whisper-preprocessor mels (Qwen3-ASR's, the chat towers' chunked one) the device served
+def metal_tower_mel_encodes() : int64 => g_tower_mels
+
+//! whisper-class encodes whose projector tail ran on the device behind the blocks
+def metal_tower_tail_encodes() : int64 => g_tower_tail_encodes
+
 [cold_path]   // the decline leg IS the fall-off-the-GPU path; its bookkeeping is not hot
 def private tw_decline(why : MetalTowerDecline) : bool {
     note_decline(g_tower_declines, "tower", "{why}", policy = why == MetalTowerDecline.knob)
@@ -108,6 +123,9 @@ def metal_tower_shutdown {
     release_handle(g_tw_ones)
     st2_slab_free(g_tw_q3a_wpad)
     st2_slab_free(g_tw_fc_twin)
+    st2_slab_free(g_tw_q8)
+    st2_slab_free(g_tw_conv1_pad)
+    st2_slab_free(g_tw_cn_front)
     st2_slab_drop()
     pool_drain(g_tw_pool)
     g_tw_failed = false
@@ -212,23 +230,243 @@ def private metal_gemma4uv_encode(t : Gemma4uvEmbedder; var s : Gemma4uvState; n
     return true
 }
 
+var private g_tw_q8 : St2SlabBase            //!< the served whisper-class tower's q8 GEMM planes as one device blob, resident until the weights drop
+var private g_tw_q8_boffs : array<uint64>    //!< a layer's regions in that blob, TW_Q8_MATS a layer: q, k, v, o, fc1, fc2
+var private g_tw_q8_conv2 = 0ul              //!< the stem's second conv in that blob
+let private TW_Q8_MATS = 6l
+let private TW_Q8_BLOCK_BYTES = Q8_QPB + Q8_SPB
+
+//! one GEMM region out of the CPU backend's layout into the q8 blob's blocks at the 16-byte-aligned cursor; answers its byte offset
+def private tw_q8_region(t : AudioTower; off, n, rows : int64; lay : Q8RepackLayout; var staging : array<uint8>; var cur : uint64&) : uint64 {
+    cur = (cur + 15ul) & ~15ul
+    let at = cur
+    q8_region_to_metal_blob(plane_at(t.qblob, off), plane_at(t.qscales, off / Q8_BLOCK_ELEMS),
+        n, rows, lay.repacked, lay.mr, lay.kgroup, lay.wbias, unsafe(addr(staging[int64(cur)])))
+    cur += uint64((rows * n / Q8_BLOCK_ELEMS) * TW_Q8_BLOCK_BYTES)
+    return at
+}
+
+//! The whisper-class tower's q8 block GEMM planes on the device, uploaded once a tower. False where the buffer cannot be made.
+[cold_path, arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private tw_q8_attach(t : AudioTower) : bool {
+    // a pure read of the layout the load repacked under: selecting again here could name another
+    let lay = active_q8_repack_layout(kernel_backend_needs_repack(active_kernel_backend()))
+    let shape = hash_combine64(hash_combine64(uint64(lay.mr), uint64(lay.kgroup)), hash_combine64(uint64(lay.wbias), lay.repacked ? 1ul : 0ul))
+    let key = hash_combine64(hash_combine64(intptr(plane_at(t.qblob, 0l)), uint64(length(t.qblob))), shape)
+    return true if (st2_slab_current(g_tw_q8, key))
+    st2_slab_free(g_tw_q8)
+    let d = t.d_model
+    let ff = t.n_ff
+    let layer_elems = 4l * d * d + 2l * d * ff
+    var staging : array<uint8>
+    staging |> reserve_resize(((t.n_layer * layer_elems + 3l * d * d) / Q8_BLOCK_ELEMS) * TW_Q8_BLOCK_BYTES + 16l * (t.n_layer * TW_Q8_MATS + 1l))
+    g_tw_q8_boffs |> resize(t.n_layer * TW_Q8_MATS)
+    var cur = 0ul
+    g_tw_q8_conv2 = tw_q8_region(t, t.conv2_w_off, 3l * d, d, lay, staging, cur)
+    for (l in range64(t.n_layer)) {
+        let lo = enc_layer_offsets(t, l)
+        var mi = 0l
+        for (woff in [lo.q_w, lo.k_w, lo.v_w, lo.o_w]) {
+            g_tw_q8_boffs[l * TW_Q8_MATS + mi] = tw_q8_region(t, woff, d, d, lay, staging, cur)
+            mi++
+        }
+        g_tw_q8_boffs[l * TW_Q8_MATS + 4l] = tw_q8_region(t, lo.fc1_w, d, ff, lay, staging, cur)
+        g_tw_q8_boffs[l * TW_Q8_MATS + 5l] = tw_q8_region(t, lo.fc2_w, ff, d, lay, staging, cur)
+    }
+    var blob = metal_new_buffer(g_dev, cur)
+    if (blob != null) {
+        unsafe {
+            memcpy(metal_buffer_contents(blob), addr(staging[0]), cur)
+        }
+        g_tw_q8.buf = blob
+        g_tw_q8.key = key
+    }
+    delete staging
+    return blob != null
+}
+
+//! one block GEMM of the whisper-class chain: region `site` of the device q8 blob on a q8 tower, tw_mm's forms on an f32 one
+def private wt_mm(enc : MetalComputeEncoder?; q8 : bool; site : int64; f16w, bf16w : bool; bwh, bblob : MetalBuffer?; welem : int64;
+                  bx, bxh, by : MetalBuffer?; bk, bn : MetalBuffer?; rows, nd, kdim : int64; cvt : bool) {
+    if (q8) {
+        if (bxh != null && cvt) {
+            enc_cvt_half(enc, bx, bxh, rows * kdim)
+        }
+        pf_enc_q8_mm(enc, g_tw_q8.buf, g_tw_q8_boffs[site], bx, bxh, by, bk, bn, rows, nd, kdim)
+    } else {
+        tw_mm(enc, f16w, bf16w, bwh, bblob, welem, bx, bxh, by, 0ul, bk, bn, rows, nd, kdim, cvt)
+    }
+}
+
 // The whisper-class block loop as ONE command buffer; the attention trio rides uend = npos (the
-// non-causal uniform span). Frontend and tail stay CPU; f32 towers only. Pad-row garbage is
+// non-causal uniform span). The mel's spectrum and the projector tail ride their own seats. Pad-row garbage is
 // CONTAINED: QK/AV zero k/v rows >= npos, softmax zeroes [uend, np32), pad outputs go unread.
 [hot_path, arch(at="../ARCHITECTURE_IMAGE.md#image-tower-twin-plane")]
-def private metal_tower_blocks(t : AudioTower; var s : EncoderState; npos : int64) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
+def private metal_tower_blocks(t : AudioTower; var s : EncoderState; npos : int64) : bool
+    => metal_tower_blocks_form(t, s, npos, TwForm.blocks)
+
+//! the blocks with the tower's post-norm behind them in the same command buffer: the normed rows land in `s.xb`
+[hot_path]
+def private metal_tower_blocks_ln_post(t : AudioTower; var s : EncoderState; npos : int64) : bool
+    => metal_tower_blocks_form(t, s, npos, TwForm.ln_post)
+
+//! the blocks with the projector tail behind them in the same command buffer where the tail's shapes ride the device (the soft
+//! tokens land in `s.out`), the blocks alone where they do not
+[hot_path]
+def private metal_tower_blocks_tail(t : AudioTower; var s : EncoderState; npos : int64) : TowerTailServed {
+    if (g_tw_tail && tw_tail_shape_ok(t, npos)) {
+        return metal_tower_blocks_form(t, s, npos, TwForm.tail) ? TowerTailServed.tail : TowerTailServed.declined
+    }
+    return metal_tower_blocks_form(t, s, npos, TwForm.blocks) ? TowerTailServed.blocks : TowerTailServed.declined
+}
+
+//! what follows the whisper-class block loop in its command buffer
+enum private TwForm {
+    blocks
+    ln_post   // the tower's post-norm: whisper's encoder output
+    tail      // the projector tail: the chat towers' soft tokens
+}
+
+//! Whether the projector tail rides the device: an f32 tower (a q8 tower's projector planes are not on the device), the tail's
+//! kernels compiled, every GEMM on the f32 tile's lattice (K a multiple of 32, N of 64) and the rms rows inside the ones row.
+def private tw_tail_shape_ok(t : AudioTower; npos : int64) : bool {
+    return false if (t.q8 || !pf_tw_tail_ready() || npos % 2l != 0l)
+    if (t.proj_kind == AudioProjKind.qwen2a) {
+        return t.d_model % 32l == 0l && t.proj_dim % 64l == 0l
+    }
+    let m1in = t.d_model * t.stack_factor
+    let mm2_in = t.proj_kind == AudioProjKind.ultravox ? t.mm1_out / 2l : t.mm1_out
+    return m1in % 32l == 0l && t.mm1_out % 64l == 0l && mm2_in % 32l == 0l && t.proj_dim % 64l == 0l
+}
+
+//! the projector tail's device rows and uniforms
+struct private TwTail {
+    rows : int64        //!< soft tokens a chunk
+    mpr : int64         //!< `rows` on the GEMM's 32-row lattice
+    bin : MetalBuffer?  //!< the first GEMM's input rows, padded to `mpr`
+    bhid : MetalBuffer? //!< the MLP projectors' hidden rows
+    bgate : MetalBuffer?//!< ultravox: the gated half rows, the second GEMM's input
+    bout : MetalBuffer? //!< the soft tokens
+    bn1 : MetalBuffer?  //!< ultravox: the pre-norm's weight row
+    bn2 : MetalBuffer?  //!< ultravox: the mid-norm's weight row
+    bytes_in : uint64
+    bytes_hid : uint64
+    bytes_gate : uint64
+    bytes_out : uint64
+    bytes_n1 : uint64
+    bytes_n2 : uint64
+    u_in : MetalBuffer?
+    u_hid : MetalBuffer?
+    u_gate : MetalBuffer?
+    u_proj : MetalBuffer?
+    u_tot : MetalBuffer?
+    u_eps6 : MetalBuffer?
+}
+
+def private tw_tail_make(t : AudioTower; npos : int64) : TwTail {
+    let d = t.d_model
+    let rows = audio_tokens_per_chunk(t)
+    let mpr = round_up(rows, 32l)
+    let mlp = t.proj_kind != AudioProjKind.qwen2a
+    let uv = t.proj_kind == AudioProjKind.ultravox
+    let m1in = mlp ? d * t.stack_factor : d
+    let half = t.mm1_out / 2l
+    var tl = TwTail(rows = rows, mpr = mpr,
+        bytes_in = uint64(max(mpr * m1in, npos * d) * 4l), bytes_hid = uint64(mpr * t.mm1_out * 4l),
+        bytes_gate = uint64(mpr * half * 4l), bytes_out = uint64(mpr * t.proj_dim * 4l),
+        bytes_n1 = uint64(m1in * 4l), bytes_n2 = uint64(half * 4l))
+    tl.bin = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_in)
+    tl.bout = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_out)
+    zero_rows(tl.bin, rows, mpr, m1in)   //! the tail's kernels write the live rows alone and the GEMMs read the row pad: the buffers are pooled
+    tl.u_in = uniform_u32(uint(m1in))
+    tl.u_proj = uniform_u32(uint(t.proj_dim))
+    tl.u_tot = uniform_u32(uint(rows * (mlp ? t.mm1_out : t.proj_dim)))
+    if (mlp) {
+        tl.bhid = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_hid)
+        tl.u_hid = uniform_u32(uint(t.mm1_out))
+    }
+    if (uv) {
+        tl.bgate = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_gate)
+        zero_rows(tl.bgate, rows, mpr, half)
+        tl.bn1 = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_n1)
+        tl.bn2 = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_n2)
+        tl.u_gate = uniform_u32(uint(half))
+        tl.u_eps6 = uniform_f32(1e-6)   // the ultravox norms' own eps, not the tower's
+        unsafe {
+            memcpy(metal_buffer_contents(tl.bn1), plane_at(t.fblob, t.normpre_off), tl.bytes_n1)
+            memcpy(metal_buffer_contents(tl.bn2), plane_at(t.fblob, t.normmid_off), tl.bytes_n2)
+        }
+    }
+    return tl
+}
+
+//! The projector tail behind the blocks, the CPU tail's steps at its widths: `bx` holds the blocks' rows, `bs` is a scratch
+//! row plane of the blocks' size.
+[arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private tw_tail_body(enc : MetalComputeEncoder?; t : AudioTower; tl : TwTail; bblob, bx, bs : MetalBuffer?;
+                         u_d, u_eps : MetalBuffer?; npos : int64) {
+    let d = t.d_model
+    let rows = tl.rows
+    if (t.proj_kind == AudioProjKind.ultravox) {   // post-norm over every position, the stacked rows normed, gated MLP
+        let half = t.mm1_out / 2l
+        enc_ln(enc, bx, bblob, uint64(t.lnp_w_off * 4l), bblob, uint64(t.lnp_b_off * 4l), bs, 0ul, u_d, u_eps, npos)
+        pf_enc_rms(enc, bs, 0ul, tl.bn1, tl.bin, tl.u_in, tl.u_eps6, rows)
+        enc_f32_mm(enc, bblob, uint64(t.proj_w_off * 4l), tl.bin, tl.bhid, 0ul, tl.u_in, tl.u_hid, tl.mpr, t.mm1_out)
+        enc_tw_swiglu_rows(enc, tl.bhid, tl.bgate, TwRowsArgs(width = uint(half), total = uint(rows * half)), rows * half)
+        pf_enc_rms(enc, tl.bgate, 0ul, tl.bn2, tl.bgate, tl.u_gate, tl.u_eps6, rows)
+        enc_f32_mm(enc, bblob, uint64(t.mm2_w_off * 4l), tl.bgate, tl.bout, 0ul, tl.u_gate, tl.u_proj, tl.mpr, t.proj_dim)
+        return
+    }
+    let tp = npos / 2l   // the pair pool BEFORE the post-norm
+    enc_tw_pool2(enc, bx, bs, TwRowsArgs(width = uint(d), total = uint(tp * d)), tp * d)
+    enc_ln(enc, bs, bblob, uint64(t.lnp_w_off * 4l), bblob, uint64(t.lnp_b_off * 4l), tl.bin, 0ul, u_d, u_eps, tp)
+    if (t.proj_kind == AudioProjKind.qwen2a) {
+        enc_f32_mm(enc, bblob, uint64(t.proj_w_off * 4l), tl.bin, tl.bout, 0ul, tl.u_in, tl.u_proj, tl.mpr, t.proj_dim)
+        enc_add_bias_rows(enc, tl.bout, 0ul, bblob, uint64(t.proj_b_off * 4l), tl.u_proj, tl.u_tot, rows * t.proj_dim)
+    } else {   // voxtral: the stacked rows through the GELU MLP
+        enc_f32_mm(enc, bblob, uint64(t.proj_w_off * 4l), tl.bin, tl.bhid, 0ul, tl.u_in, tl.u_hid, tl.mpr, t.mm1_out)
+        enc_gelu_erf(enc, tl.bhid, 0ul, tl.u_tot, rows * t.mm1_out)
+        enc_f32_mm(enc, bblob, uint64(t.mm2_w_off * 4l), tl.bhid, tl.bout, 0ul, tl.u_hid, tl.u_proj, tl.mpr, t.proj_dim)
+    }
+}
+
+//! the tail's soft tokens into `s.out` where the command buffer ran; the tail's buffers released
+def private tw_tail_land(t : AudioTower; var tl : TwTail; ran : bool; var s : EncoderState) {
+    if (ran) {
+        unsafe {
+            memcpy(addr(s.out[0]), metal_buffer_contents(tl.bout), uint64(tl.rows * t.proj_dim * 4l))
+        }
+        g_tower_tail_encodes++
+    }
+    pool_release(g_tw_pool, tl.bin, tl.bytes_in)
+    pool_release(g_tw_pool, tl.bout, tl.bytes_out)
+    pool_release(g_upool, tl.u_in, 4ul)
+    pool_release(g_upool, tl.u_proj, 4ul)
+    pool_release(g_upool, tl.u_tot, 4ul)
+    if (tl.bhid != null) {
+        pool_release(g_tw_pool, tl.bhid, tl.bytes_hid)
+        pool_release(g_upool, tl.u_hid, 4ul)
+    }
+    if (tl.bgate != null) {
+        pool_release(g_tw_pool, tl.bgate, tl.bytes_gate)
+        pool_release(g_tw_pool, tl.bn1, tl.bytes_n1)
+        pool_release(g_tw_pool, tl.bn2, tl.bytes_n2)
+        pool_release(g_upool, tl.u_gate, 4ul)
+        pool_release(g_upool, tl.u_eps6, 4ul)
+    }
+}
+
+[hot_path, arch(at="../ARCHITECTURE_IMAGE.md#image-tower-twin-plane")]
+def private metal_tower_blocks_form(t : AudioTower; var s : EncoderState; npos : int64; form : TwForm) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
     if (!g_tw_env_tower) {
         return tw_decline(MetalTowerDecline.knob)
     }
-    if (t.q8) {
-        return tw_decline(MetalTowerDecline.quant_mode)
-    }
     let d = t.d_model
     let hs = d / t.n_head
     if (d % 64l != 0l || t.n_ff % 64l != 0l || hs % 64l != 0l || t.layers_off % 4l != 0l || t.layer_stride % 4l != 0l) {
         return tw_decline(MetalTowerDecline.shape)
     }
-    if (!metal_tower_init()) {   // per-encode: re-arms after any shutdown seat
+    if (!metal_tower_init() || (t.q8 && !tw_q8_attach(t))) {   // per-encode: re-arms after any shutdown seat
         return tw_decline(MetalTowerDecline.device)
     }
     residency_flush()   // pin/commit before the first submission (the post-CPU-window slack)
@@ -242,11 +480,11 @@ def private metal_tower_blocks(t : AudioTower; var s : EncoderState; npos : int6
     let bytes_att = uint64(t.n_head * mp * nk64 * 2l)
     let bytes_rowk = uint64(nk64 * d * 4l)   //! K panel: the QK grid walks nk64 key rows, past mp
     let bytes_stat = uint64(t.n_head * mp * 2l * 4l)
-    let twin = g_tw_env_tower_f16 && length(t.wblob) > 0l
+    let twin = !t.q8 && g_tw_env_tower_f16 && length(t.wblob) > 0l
     let f16_route = twin && !t.blk_bf16 && pf_hmm_ready()
     let bf16_route = twin && t.blk_bf16
     let bytes_xh = uint64(mp * ff * 2l)
-    var bxh = (f16_route || (bf16_route && pf_bf16_half_ready())) ? pool_acquire_pinned(g_tw_pool, g_dev, bytes_xh) : null
+    var bxh = (f16_route || (bf16_route && pf_bf16_half_ready()) || (t.q8 && pf_q8_mm_half())) ? pool_acquire_pinned(g_tw_pool, g_dev, bytes_xh) : null
     var bwh = (f16_route || bf16_route) ? plane_buffer(g_dev, unsafe(reinterpret<void?>(plane_at(t.wblob, 0l))), uint64(length(t.wblob) * 2l), mapped) : null
     let f16w = f16_route && bwh != null && bxh != null
     let bf16w = bf16_route && bwh != null
@@ -269,42 +507,55 @@ def private metal_tower_blocks(t : AudioTower; var s : EncoderState; npos : int6
     var ka = AttnArgs(qd = uint(d), kv_dim = uint(d), head_size = uint(hs), kv_mul = 1u,
         npos = uint(npos), np32 = uint(nk64), scale = 1.0 / sqrt(float(hs)),
         qoff = 0u, qrows = uint(mp), window = 0u, softcap = 0.0, hass = 0u, uend = uint(npos))
+    var tl = form == TwForm.tail ? tw_tail_make(t, npos) : TwTail()
     var err = ""
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
         for (l in range64(t.n_layer)) {
             let lo = enc_layer_offsets(t, l)
             enc_ln(enc, bx, bblob, uint64(lo.ln1_w * 4l), bblob, uint64(lo.ln1_b * 4l), bxb, 0ul, u_d, u_eps, npos)
-            tw_mm(enc, f16w, bf16w, bwh, bblob, lo.q_w, bxb, bxh, bq, 0ul, u_d, u_d, mp, d, d, true)
+            wt_mm(enc, t.q8, l * TW_Q8_MATS, f16w, bf16w, bwh, bblob, lo.q_w, bxb, bxh, bq, u_d, u_d, mp, d, d, true)
             enc_add_bias_rows(enc, bq, 0ul, bblob, uint64(lo.q_b * 4l), u_d, u_totd, npos * d)
-            tw_mm(enc, f16w, bf16w, bwh, bblob, lo.k_w, bxb, bxh, bk, 0ul, u_d, u_d, mp, d, d, false)
+            wt_mm(enc, t.q8, l * TW_Q8_MATS + 1l, f16w, bf16w, bwh, bblob, lo.k_w, bxb, bxh, bk, u_d, u_d, mp, d, d, false)
             if (t.has_k_bias) {
                 enc_add_bias_rows(enc, bk, 0ul, bblob, uint64(lo.k_b * 4l), u_d, u_totd, npos * d)
             }
-            tw_mm(enc, f16w, bf16w, bwh, bblob, lo.v_w, bxb, bxh, bv, 0ul, u_d, u_d, mp, d, d, false)
+            wt_mm(enc, t.q8, l * TW_Q8_MATS + 2l, f16w, bf16w, bwh, bblob, lo.v_w, bxb, bxh, bv, u_d, u_d, mp, d, d, false)
             enc_add_bias_rows(enc, bv, 0ul, bblob, uint64(lo.v_b * 4l), u_d, u_totd, npos * d)
             enc_qk_mm(enc, bq, bk, batt, ka, mp, nk64, t.n_head)
             enc_rowstat(enc, batt, ka, bstat, null, npos, t.n_head)
             enc_av_mm(enc, batt, bv, bxb2, ka, bstat, mp, t.n_head, hs)
-            tw_mm(enc, f16w, bf16w, bwh, bblob, lo.o_w, bxb2, bxh, bxb, 0ul, u_d, u_d, mp, d, d, true)
+            wt_mm(enc, t.q8, l * TW_Q8_MATS + 3l, f16w, bf16w, bwh, bblob, lo.o_w, bxb2, bxh, bxb, u_d, u_d, mp, d, d, true)
             enc_add_bias_rows(enc, bxb, 0ul, bblob, uint64(lo.o_b * 4l), u_d, u_totd, npos * d)
             enc_add(enc, bx, 0ul, bxb, 0ul, u_totd, npos * d)
             enc_ln(enc, bx, bblob, uint64(lo.ln2_w * 4l), bblob, uint64(lo.ln2_b * 4l), bxb, 0ul, u_d, u_eps, npos)
-            tw_mm(enc, f16w, bf16w, bwh, bblob, lo.fc1_w, bxb, bxh, bh, 0ul, u_d, u_ff, mp, ff, d, true)
+            wt_mm(enc, t.q8, l * TW_Q8_MATS + 4l, f16w, bf16w, bwh, bblob, lo.fc1_w, bxb, bxh, bh, u_d, u_ff, mp, ff, d, true)
             enc_add_bias_rows(enc, bh, 0ul, bblob, uint64(lo.fc1_b * 4l), u_ff, u_totff, npos * ff)
             if (t.gelu_tanh) {
                 enc_gelu_lut(enc, bh, 0ul, u_totff, npos * ff)
             } else {
                 enc_gelu_erf(enc, bh, 0ul, u_totff, npos * ff)
             }
-            tw_mm(enc, f16w, bf16w, bwh, bblob, lo.fc2_w, bh, bxh, bxb2, 0ul, u_ff, u_d, mp, d, ff, true)
+            wt_mm(enc, t.q8, l * TW_Q8_MATS + 5l, f16w, bf16w, bwh, bblob, lo.fc2_w, bh, bxh, bxb2, u_ff, u_d, mp, d, ff, true)
             enc_add_bias_rows(enc, bxb2, 0ul, bblob, uint64(lo.fc2_b * 4l), u_d, u_totd, npos * d)
             enc_add(enc, bx, 0ul, bxb2, 0ul, u_totd, npos * d)
         }
+        if (form == TwForm.ln_post) {
+            enc_ln(enc, bx, bblob, uint64(t.lnp_w_off * 4l), bblob, uint64(t.lnp_b_off * 4l), bxb, 0ul, u_d, u_eps, npos)
+        } elif (form == TwForm.tail) {
+            tw_tail_body(enc, t, tl, bblob, bx, bxb, u_d, u_eps, npos)
+        }
+    }
+    if (form == TwForm.tail) {
+        tw_tail_land(t, tl, ran, s)
     }
     var served = false
     if (ran) {
-        unsafe {
-            memcpy(addr(s.x[0]), metal_buffer_contents(bx), uint64(npos * d * 4l))
+        unsafe {   // the post-norm seat lands the normed rows where the CPU post-norm would: `s.xb`; the tail seat landed `s.out`
+            if (form == TwForm.ln_post) {
+                memcpy(addr(s.xb[0]), metal_buffer_contents(bxb), uint64(npos * d * 4l))
+            } elif (form == TwForm.blocks) {
+                memcpy(addr(s.x[0]), metal_buffer_contents(bx), uint64(npos * d * 4l))
+            }
         }
         tw_count_encode(npos, t.n_layer, f16w || bf16w)
         served = true
@@ -447,7 +698,7 @@ struct private G4aGpuCtx : TwGpuCtx {
 def private g4a_shape_ok(t : Gemma4aEncoder) : bool {
     let d = t.d_model
     return (!t.q8 && d % 64l == 0l && t.n_ff % 64l == 0l && t.n_head * t.d_head == d
-        && gemma4a_attn_past() <= 15l)
+        && gemma4a_attn_past() <= 15l && gemma4a_mid_dim(t) % 64l == 0l && t.proj_dim % 64l == 0l && gemma4a_mid_dim(t) <= int64(TW_ONES_DIM))
 }
 
 def private g4a_ctx_make(t : Gemma4aEncoder; npos : int64) : G4aGpuCtx {
@@ -493,6 +744,53 @@ def private g4a_ctx_release(var c : G4aGpuCtx) {
     tw_ctx_release(c)
 }
 
+//! the projector tail's device rows and uniforms: the encoder-width rows the out projection lands, the decoder-width soft tokens
+struct private G4aTail {
+    btmp : MetalBuffer?
+    bout : MetalBuffer?
+    u_mid : MetalBuffer?
+    u_proj : MetalBuffer?
+    u_totmid : MetalBuffer?
+    bytes_tmp : uint64
+    bytes_out : uint64
+}
+
+def private g4a_tail_make(t : Gemma4aEncoder; c : G4aGpuCtx) : G4aTail {
+    let mid = gemma4a_mid_dim(t)
+    let bytes_tmp = uint64(c.mp * mid * 4l)
+    let bytes_out = uint64(c.mp * t.proj_dim * 4l)
+    return G4aTail(bytes_tmp = bytes_tmp, bytes_out = bytes_out,
+        btmp = pool_acquire_pinned(g_tw_pool, g_dev, bytes_tmp), bout = pool_acquire_pinned(g_tw_pool, g_dev, bytes_out),
+        u_mid = uniform_u32(uint(mid)), u_proj = uniform_u32(uint(t.proj_dim)), u_totmid = uniform_u32(uint(c.npos * mid)))
+}
+
+//! The projector tail behind the blocks, in the blocks' command buffer: the out projection and its bias, the weightless
+//! norm, the audio embedder - the CPU tail's four steps at its widths.
+[arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private g4a_tail_body(enc : MetalComputeEncoder?; t : Gemma4aEncoder; c : G4aGpuCtx; tl : G4aTail) {
+    let mid = gemma4a_mid_dim(t)
+    enc_f32_mm(enc, c.bblob, uint64(t.outproj_w * 4l), c.bx, tl.btmp, 0ul, c.u_d, tl.u_mid, c.mp, mid)
+    enc_add_bias_rows(enc, tl.btmp, 0ul, c.bblob, uint64(t.outproj_b * 4l), tl.u_mid, tl.u_totmid, c.npos * mid)
+    pf_enc_rms(enc, tl.btmp, 0ul, g_tw_ones, tl.btmp, tl.u_mid, c.u_eps, c.npos)
+    enc_f32_mm(enc, c.bblob, uint64(t.mmproj_w * 4l), tl.btmp, tl.bout, 0ul, tl.u_mid, tl.u_proj, c.mp, t.proj_dim)
+}
+
+//! the tail's soft tokens into `s.out` where the command buffer ran, the CPU tail told to stand down; the tail's buffers released
+def private g4a_tail_land(t : Gemma4aEncoder; c : G4aGpuCtx; var tl : G4aTail; ran : bool; var s : Gemma4aState) {
+    if (ran) {
+        ensure_length(s.out, c.npos * t.proj_dim)
+        unsafe {
+            memcpy(addr(s.out[0]), metal_buffer_contents(tl.bout), uint64(c.npos * t.proj_dim * 4l))
+        }
+        s.out_ready = true
+    }
+    pool_release(g_tw_pool, tl.btmp, tl.bytes_tmp)
+    pool_release(g_tw_pool, tl.bout, tl.bytes_out)
+    pool_release(g_upool, tl.u_mid, 4ul)
+    pool_release(g_upool, tl.u_proj, 4ul)
+    pool_release(g_upool, tl.u_totmid, 4ul)
+}
+
 //! The 12-block dispatch chain on an already-armed context - the blocks-only and whole-chunk drivers share it.
 [arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
 def private g4a_blocks_body(enc : MetalComputeEncoder?; t : Gemma4aEncoder; c : G4aGpuCtx) {
@@ -565,12 +863,15 @@ def private metal_gemma4a_blocks(t : Gemma4aEncoder; var s : Gemma4aState; npos
     residency_flush()   // pin/commit before the first submission (the post-CPU-front slack)
     let d = t.d_model
     var c <- g4a_ctx_make(t, npos)
+    var tl <- g4a_tail_make(t, c)
     upload_rows_padded(c.bx, unsafe(addr(s.x[0])), npos, c.mp, d)
     var err = ""
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
         g4a_blocks_body(enc, t, c)
+        g4a_tail_body(enc, t, c, tl)
     }
     let served = tw_readback(c, ran, s.x, d, t.n_layer)
+    g4a_tail_land(t, c, tl, ran, s)
     g4a_ctx_release(c)
     if (!served) {
         return tw_decline(MetalTowerDecline.gpu_error)
@@ -907,7 +1208,7 @@ def private fc_run(blob : PlaneF; mapped : bool; d, n_ff, n_head, nk, n_layer :
     }
 }
 
-//! The canary FastConformer block loop as ONE command buffer on the f32 blob; the subsample front, mel and final proj stay CPU.
+//! The canary FastConformer block loop as ONE command buffer on the f32 blob; the front seat runs the mel and the subsample front ahead of it, the final proj stays CPU.
 [hot_path]
 def private metal_canary_blocks(t : CanaryEncoder; var st : CanaryState; npos, ww : int64) : bool {
     if (!g_tw_env_tower) {
@@ -923,6 +1224,142 @@ def private metal_canary_blocks(t : CanaryEncoder; var st : CanaryState; npos, w
     }
 }
 
+var private @scratch g_tw_cn_bufs : array<MetalBuffer?>   //!< the canary front's pooled buffers of one encode, taken and given back inside it
+var private g_tw_cn_front : St2SlabBase   //!< the served canary encoder's three front convs with their taps tap-major: the front kernels' layout
+
+//! Canary's first conv and its two depthwise convs on the device as [9][ch] panels, one after another - the file keeps
+//! them [ch][9] - once an encoder. Null where the buffer cannot be made.
+[cold_path]
+def private tw_cn_front_attach(t : CanaryEncoder) : MetalBuffer? {
+    let key = hash_combine64(tw_plane_key(t.blob), uint64(t.c0_w))
+    return g_tw_cn_front.buf if (st2_slab_current(g_tw_cn_front, key))
+    st2_slab_free(g_tw_cn_front)
+    let nch = t.n_sub_ch
+    var taps = metal_new_buffer(g_dev, uint64(3l * 9l * nch * 4l))
+    return null if (taps == null)
+    unsafe {
+        var p = reinterpret<float?>(metal_buffer_contents(taps))
+        for (panel, woff in range64(3l), [t.c0_w, t.c2_w, t.c5_w]) {
+            for (c in range64(nch)) {
+                for (tap in range64(9l)) {
+                    p[(panel * 9l + tap) * nch + c] = t.blob[woff + c * 9l + tap]
+                }
+            }
+        }
+    }
+    g_tw_cn_front.buf = taps
+    g_tw_cn_front.key = key
+    return taps
+}
+
+//! The canary front whole, off the windowed frames `st.xw`, as ONE command buffer: the mel, the subsample stack and the
+//! input projection into `st.x`, the CPU front's stages in its order. A stage's valid rows are its conv's image height:
+//! a row past them reads as the zero the CPU masks it to. Answers the encoder rows, or -1 where the CPU front runs.
+[hot_path, arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private metal_canary_front(t : CanaryEncoder; var st : CanaryState) : int64 {   // nolint:STYLE038 — the dispatch chain is the shape
+    if (!g_tw_env_tower || t.q8) {
+        return -1l
+    }
+    let d = t.d_model
+    let nch = t.n_sub_ch
+    let n_mel = t.n_mel
+    let n_fft = t.n_fft
+    let n_bins = t.n_fb
+    let n_len = st.n_len
+    let t1 = conv_s2_out(n_len)
+    let w1 = conv_s2_out(n_mel)
+    let t2 = conv_s2_out(t1)
+    let w2 = conv_s2_out(w1)
+    let tt = conv_s2_out(t2)
+    let w3 = conv_s2_out(w2)
+    let l0 = conv_s2_out(st.n_valid)   //! the valid rows of each stage: the CPU front's length mask
+    let l2 = conv_s2_out(l0)
+    let feat = w3 * nch
+    let bytes_y0 = uint64(t1 * w1 * nch * 4l)
+    if (n_len < 1l || nch % 64l != 0l || feat % 32l != 0l || n_mel % 64l != 0l || n_fft % 32l != 0l || d % 64l != 0l
+            || bytes_y0 > uint64(PK_FRONT_MAX_BYTES) || !metal_tower_init() || !pf_cn_front_ready()) {
+        return -1l
+    }
+    var btaps = tw_cn_front_attach(t)
+    return -1l if (btaps == null)
+    residency_flush()
+    let mp = round_up(n_len, 32l)
+    let rows2 = t2 * w2
+    let rows3 = tt * w3
+    let mp2 = round_up(rows2, 32l)
+    let mp3 = round_up(rows3, 32l)
+    let mpt = round_up(tt, 32l)
+    let dft_out_pad = round_up(2l * n_bins, 64l)
+    let ldpow = round_up(n_bins, 32l)
+    var bblob = plane_buffer(g_dev, unsafe(reinterpret<void?>(plane_at(t.blob, 0l))), uint64(length(t.blob) * 4l), t.image_map != null)
+    let sizes = fixed_array(uint64(mp * n_fft * 4l), uint64(dft_out_pad * n_fft * 4l), uint64(mp * dft_out_pad * 4l),
+        uint64(mp * ldpow * 4l), uint64(n_mel * ldpow * 4l), uint64(mp * n_mel * 4l), bytes_y0,
+        uint64(mp2 * nch * 4l), uint64(mp2 * nch * 4l), uint64(mp3 * nch * 4l), uint64(mp3 * nch * 4l),
+        uint64(mpt * feat * 4l), uint64(mpt * d * 4l))
+    g_tw_cn_bufs |> resize(length(sizes))
+    assume bufs = g_tw_cn_bufs
+    for (b, n in bufs, sizes) {
+        b = pool_acquire_pinned(g_tw_pool, g_dev, n)
+    }
+    upload_rows_strided(bufs[0], unsafe(addr<float const?>(st.xw[0])), n_len, n_fft, n_fft)
+    zero_rows(bufs[0], n_len, mp, n_fft)
+    tw_twiddle_panel(bufs[1], plane_at(t.twiddles, 0l), n_bins, n_fft, n_fft, dft_out_pad)
+    upload_rows_strided(bufs[4], plane_at(t.filters, 0l), n_mel, n_bins, ldpow)
+    unsafe {   //! the depthwise convs write their live rows alone, and the GEMM behind each reads the row pad: zero it, the buffers are pooled
+        memset8(reinterpret<uint8?>(metal_buffer_contents(bufs[7])) + rows2 * nch * 4l, uint8(0), int((mp2 - rows2) * nch * 4l))
+        memset8(reinterpret<uint8?>(metal_buffer_contents(bufs[9])) + rows3 * nch * 4l, uint8(0), int((mp3 - rows3) * nch * 4l))
+    }
+    var u_kfft = uniform_u32(uint(n_fft))
+    var u_dft = uniform_u32(uint(dft_out_pad))
+    var u_nbins = uniform_u32(uint(n_bins))
+    var u_ldpow = uniform_u32(uint(ldpow))
+    var u_totpow = uniform_u32(uint(mp * ldpow))
+    var u_nmel = uniform_u32(uint(n_mel))
+    var u_nch = uniform_u32(uint(nch))
+    var u_feat = uniform_u32(uint(feat))
+    var u_d = uniform_u32(uint(d))
+    var u_tot2 = uniform_u32(uint(rows2 * nch))
+    var u_tot3 = uniform_u32(uint(rows3 * nch))
+    var u_totd = uniform_u32(uint(tt * d))
+    var kn = CnMelNormArgs(nmel = uint(n_mel), nlen = uint(n_len), valid = uint(min(st.n_valid, n_len)), mfloor = 5.960464477539063e-08)   //! 2^-24, the CPU form's log guard
+    var a0 = PkFrontArgs(iw = uint(n_mel), ih = uint(n_len), ow = uint(w1), oh = uint(t1), ch = uint(nch), total = uint(t1 * w1 * nch))
+    var a2 = PkFrontArgs(iw = uint(w1), ih = uint(min(l0, t1)), ow = uint(w2), oh = uint(t2), ch = uint(nch), total = uint(rows2 * nch))
+    var a5 = PkFrontArgs(iw = uint(w2), ih = uint(min(l2, t2)), ow = uint(w3), oh = uint(tt), ch = uint(nch), total = uint(rows3 * nch))
+    var axf = PkFrontArgs(ow = uint(w3), oh = uint(tt), ch = uint(nch), total = uint(mpt * feat))
+    let panel = uint64(9l * nch * 4l)
+    var err = ""
+    let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
+        enc_f32_mm(enc, bufs[1], 0ul, bufs[0], bufs[2], 0ul, u_kfft, u_dft, mp, dft_out_pad)
+        enc_q3a_pow(enc, bufs[2], bufs[3], u_nbins, u_dft, u_ldpow, u_totpow, mp * ldpow)
+        enc_f32_mm(enc, bufs[4], 0ul, bufs[3], bufs[5], 0ul, u_ldpow, u_nmel, mp, n_mel)
+        enc_cn_melnorm(enc, bufs[5], kn, n_mel)
+        enc_pk_conv0(enc, bufs[5], bufs[6], btaps, 0ul, bblob, uint64(t.c0_b * 4l), a0, int64(a0.total))
+        enc_pk_dw2d(enc, bufs[6], bufs[7], btaps, panel, bblob, uint64(t.c2_b * 4l), a2, int64(a2.total))
+        enc_f32_mm(enc, bblob, uint64(t.c3_w * 4l), bufs[7], bufs[8], 0ul, u_nch, u_nch, mp2, nch)
+        enc_bias_relu_rows(enc, bufs[8], 0ul, bblob, uint64(t.c3_b * 4l), u_nch, u_tot2, rows2 * nch)
+        enc_pk_dw2d(enc, bufs[8], bufs[9], btaps, 2ul * panel, bblob, uint64(t.c5_b * 4l), a5, int64(a5.total))
+        enc_f32_mm(enc, bblob, uint64(t.c6_w * 4l), bufs[9], bufs[10], 0ul, u_nch, u_nch, mp3, nch)
+        enc_bias_relu_rows(enc, bufs[10], 0ul, bblob, uint64(t.c6_b * 4l), u_nch, u_tot3, rows3 * nch)
+        enc_pk_xf(enc, bufs[10], bufs[11], axf, mpt * feat)
+        enc_f32_mm(enc, bblob, uint64(t.pre_w * 4l), bufs[11], bufs[12], 0ul, u_feat, u_d, mpt, d)
+        enc_add_bias_rows(enc, bufs[12], 0ul, bblob, uint64(t.pre_b * 4l), u_d, u_totd, tt * d)
+    }
+    if (ran) {
+        ensure_length(st.x, tt * d)
+        unsafe {
+            memcpy(addr(st.x[0]), metal_buffer_contents(bufs[12]), uint64(tt * d * 4l))
+        }
+        g_tower_convs++
+    }
+    for (b, n in bufs, sizes) {
+        pool_release(g_tw_pool, b, n)
+    }
+    for (u in fixed_array(u_kfft, u_dft, u_nbins, u_ldpow, u_totpow, u_nmel, u_nch, u_feat, u_d, u_tot2, u_tot3, u_totd)) {
+        pool_release(g_upool, u, 4ul)
+    }
+    return ran ? tt : -1l
+}
+
 //! Parakeet's block offsets in the shared chain's layout: the same regions, no GEMM biases (-1).
 def private pk_fc_layer(lo : PkLayerOffs) : CanaryLayerOffs {
     return CanaryLayerOffs(nf1_w = lo.nf1_w, nf1_b = lo.nf1_b,
@@ -1096,6 +1533,7 @@ def private metal_gemma4a_chunk(t : Gemma4aEncoder; var s : Gemma4aState; n_len
     let kd1 = t.sub_ch0 * 9l
     let conv1_cout_pad = round_up(t.sub_ch1, 64l)
     var c <- g4a_ctx_make(t, npos)
+    var tl <- g4a_tail_make(t, c)
     let bytes_xw = uint64(mpd * n_fft * 4l)
     let bytes_tw = uint64(dft_out_pad * n_fft * 4l)
     let bytes_reim = uint64(mpd * dft_out_pad * 4l)
@@ -1167,7 +1605,9 @@ def private metal_gemma4a_chunk(t : Gemma4aEncoder; var s : Gemma4aState; n_len
         //! input projection: [npos x feat] -> [npos x d]
         enc_f32_mm(enc, c.bblob, uint64(t.inproj_w * 4l), c.bxb, c.bx, 0ul, u_feat, c.u_d, c.mp, d)
         g4a_blocks_body(enc, t, c)
+        g4a_tail_body(enc, t, c, tl)
     }
+    g4a_tail_land(t, c, tl, ran, s)
     var served = false
     if (ran) {
         ensure_length(s.x, npos * d)
@@ -1223,9 +1663,137 @@ def private metal_gemma4a_chunk(t : Gemma4aEncoder; var s : Gemma4aState; n_len
     return npos
 }
 
+//! the gemma4v chain's two ends on the device: the stem's columns and position rows ahead of the blocks, the projector
+//! tail's rows behind them
+struct private G4vEnds {
+    tail : bool             //!< the tail rides this encode's command buffer
+    n_cols : int64          //!< the patch grid's width
+    nout : int64            //!< soft tokens: the pooled grid's rows
+    mpo : int64             //!< `nout` on the GEMM's 32-row lattice
+    bx0 : MetalBuffer?      //!< the stem's columns [mp x patch_dim]
+    bpos : MetalBuffer?     //!< each row's x + y position-table rows, summed
+    bpool : MetalBuffer?    //!< the pooled rows [mpo x d]
+    bclamp : MetalBuffer?   //!< their clamped copy, the projection's input
+    bout : MetalBuffer?     //!< the soft tokens [mpo x proj_dim]
+    bstd_b : MetalBuffer?   //!< the standardize bias row (zeros where the tower has none)
+    bstd_m : MetalBuffer?   //!< its scale row (ones)
+    u_pd : MetalBuffer?
+    u_proj : MetalBuffer?
+    u_totpool : MetalBuffer?
+    u_totout : MetalBuffer?
+    bytes_x0 : uint64
+    bytes_pos : uint64
+    bytes_pool : uint64
+    bytes_out : uint64
+    bytes_std : uint64
+}
+
+//! The stem's operands up, and the tail's rows where the lever allows, its kernels are compiled, the grid pools whole and
+//! the projection sits on its GEMM's lattice.
+def private g4v_ends_make(t : Gemma4vTower; s : Gemma4vState; npos, mp : int64) : G4vEnds {
+    let d = t.n_embd
+    let n_cols = s.grid_w
+    var e = G4vEnds(n_cols = n_cols, bytes_x0 = uint64(mp * t.patch_dim * 4l), bytes_pos = uint64(mp * d * 4l))
+    e.bx0 = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_x0)
+    e.bpos = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_pos)
+    e.u_pd = uniform_u32(uint(t.patch_dim))
+    unsafe {
+        upload_rows_padded(e.bx0, addr<float const?>(s.x0[0]), npos, mp, t.patch_dim)
+        var pp = reinterpret<float?>(metal_buffer_contents(e.bpos))
+        let tbl = plane_at(t.blob, t.pos_w)
+        for (pi in range64(npos)) {
+            let ex = tbl + (pi % n_cols) * d
+            let ey = tbl + (t.pos_entries + pi / n_cols) * d
+            for (i in range64(d)) {
+                pp[pi * d + i] = ex[i] + ey[i]
+            }
+        }
+    }
+    e.tail = (g_tw_tail && pf_tw_tail_ready() && n_cols % t.merge == 0l && s.grid_h % t.merge == 0l
+        && d <= int64(TW_ONES_DIM) && t.proj_dim % 64l == 0l)
+    return e if (!e.tail)
+    e.nout = (n_cols / t.merge) * (s.grid_h / t.merge)
+    e.mpo = round_up(e.nout, 32l)
+    e.bytes_pool = uint64(e.mpo * d * 4l)
+    e.bytes_out = uint64(e.mpo * t.proj_dim * 4l)
+    e.bytes_std = uint64(d * 4l)
+    e.bpool = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_pool)
+    e.bclamp = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_pool)
+    zero_rows(e.bpool, e.nout, e.mpo, d)   //! the pool and the clamp write the live rows alone and the projection reads the row pad: the buffers are pooled
+    zero_rows(e.bclamp, e.nout, e.mpo, d)
+    e.bout = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_out)
+    e.bstd_b = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_std)
+    e.bstd_m = pool_acquire_pinned(g_tw_pool, g_dev, e.bytes_std)
+    e.u_proj = uniform_u32(uint(t.proj_dim))
+    e.u_totpool = uniform_u32(uint(e.nout * d))
+    e.u_totout = uniform_u32(uint(e.nout * t.proj_dim))
+    unsafe {
+        var bp = reinterpret<float?>(metal_buffer_contents(e.bstd_b))
+        var mp_ = reinterpret<float?>(metal_buffer_contents(e.bstd_m))
+        for (i in range64(d)) {
+            bp[i] = t.has_std ? plane_at(t.blob, t.std_bias)[i] : 0.0
+            mp_[i] = t.has_std ? plane_at(t.blob, t.std_scale)[i] : 1.0
+        }
+    }
+    return e
+}
+
+//! one GEMM off the tower's weights: the halfword twin where the tensor is stored bf16, the f32 blob otherwise
+
+//! The stem on the device: the patch conv over the columns, then each row's position rows.
+[arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private g4v_stem_body(enc : MetalComputeEncoder?; t : Gemma4vTower; e : G4vEnds; bblob, bwblob, bx : MetalBuffer?;
+                          u_d, u_totd : MetalBuffer?; mp, npos : int64) {
+    let d = t.n_embd
+    tw_mm(enc, false, t.patch_bf16, bwblob, bblob, t.patch_w, e.bx0, null, bx, 0ul, e.u_pd, u_d, mp, d, t.patch_dim, false)
+    enc_add(enc, bx, 0ul, e.bpos, 0ul, u_totd, npos * d)
+}
+
+//! The CPU tail's steps behind the blocks: the grid mean pool, the sqrt(d) scale and the standardize, the weightless
+//! rms, then the projection between its two clamps.
+[arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private g4v_tail_body(enc : MetalComputeEncoder?; t : Gemma4vTower; e : G4vEnds; bblob, bwblob, bx : MetalBuffer?;
+                          u_d, u_eps, u_in, u_out : MetalBuffer?) {
+    return if (!e.tail)
+    let d = t.n_embd
+    let nout = e.nout
+    let cb = uint64(t.proj_clamp * 4l)
+    enc_tw_pool2d(enc, bx, e.bpool, TwPool2dArgs(width = uint(d), gw = uint(e.n_cols), k = uint(t.merge),
+        ow = uint(e.n_cols / t.merge), total = uint(nout * d)), nout * d)
+    enc_tw_affine_rows(enc, e.bpool, e.bstd_b, e.bstd_m, TwAffineArgs(width = uint(d), total = uint(nout * d), scale = sqrt(float(d))), nout * d)
+    pf_enc_rms(enc, e.bpool, 0ul, g_tw_ones, e.bpool, u_d, u_eps, nout)
+    enc_clamp(enc, e.bpool, 0ul, e.bclamp, 0ul, bblob, cb, u_in, e.u_totpool, nout * d)
+    tw_mm(enc, false, t.proj_bf16, bwblob, bblob, t.proj_w, e.bclamp, null, e.bout, 0ul, u_d, e.u_proj, e.mpo, t.proj_dim, d, false)
+    enc_clamp(enc, e.bout, 0ul, e.bout, 0ul, bblob, cb, u_out, e.u_totout, nout * t.proj_dim)
+}
+
+//! the tail's soft tokens into `s.tail` where the command buffer ran, the CPU tail told to stand down; the ends' buffers released
+def private g4v_ends_land(t : Gemma4vTower; var e : G4vEnds; ran : bool; var s : Gemma4vState) {
+    pool_release(g_tw_pool, e.bx0, e.bytes_x0)
+    pool_release(g_tw_pool, e.bpos, e.bytes_pos)
+    pool_release(g_upool, e.u_pd, 4ul)
+    return if (!e.tail)
+    if (ran) {
+        ensure_length(s.tail, e.nout * t.proj_dim)
+        unsafe {
+            memcpy(addr(s.tail[0]), metal_buffer_contents(e.bout), uint64(e.nout * t.proj_dim * 4l))
+        }
+        s.tail_ready = true
+        g_tower_tail_encodes++
+    }
+    pool_release(g_tw_pool, e.bpool, e.bytes_pool)
+    pool_release(g_tw_pool, e.bclamp, e.bytes_pool)
+    pool_release(g_tw_pool, e.bout, e.bytes_out)
+    pool_release(g_tw_pool, e.bstd_b, e.bytes_std)
+    pool_release(g_tw_pool, e.bstd_m, e.bytes_std)
+    pool_release(g_upool, e.u_proj, 4ul)
+    pool_release(g_upool, e.u_totpool, 4ul)
+    pool_release(g_upool, e.u_totout, 4ul)
+}
+
 // The gemma4v ViT block loop as ONE command buffer on the file's planes (bf16 GEMMs through the
 // bf16 mul_mm, f32 norms/clamps) — the CPU g4v_block chain dispatch for dispatch, the attention
-// trio at uend = npos / scale 1. Stem and tail stay CPU; a q8-lane tower declines (quant_mode).
+// trio at uend = npos / scale 1. The stem and the tail ride the same command buffer (`g4v_ends_make`); a q8-lane tower declines (quant_mode).
 [hot_path]
 def private metal_gemma4v_blocks(t : Gemma4vTower; var s : Gemma4vState; npos : int64) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
     if (!g_tw_env_tower) {
@@ -1239,7 +1807,7 @@ def private metal_gemma4v_blocks(t : Gemma4vTower; var s : Gemma4vState; npos :
     let ff = t.n_ff
     // bf16 GEMMs only; hs 64 = one attention K-slab; GEMM regions bind as ushort4 views (8-aligned halfword offsets)
     if (!t.blk_bf16 || d % 64l != 0l || ff % 64l != 0l || hs != 64l || t.layer_w % 8l != 0l
-            || t.layer_w_stride % 8l != 0l) {
+            || t.layer_w_stride % 8l != 0l || t.patch_dim % 32l != 0l || s.grid_w * s.grid_h != npos) {
         return tw_decline(MetalTowerDecline.shape)
     }
     if (!metal_tower_init()) {   // per-encode: re-arms after any shutdown seat
@@ -1269,11 +1837,9 @@ def private metal_gemma4v_blocks(t : Gemma4vTower; var s : Gemma4vState; npos :
     var batt = pool_acquire_pinned(g_tw_pool, g_dev, bytes_att)
     var bstat = pool_acquire_pinned(g_tw_pool, g_dev, bytes_stat)
     var btabs = pool_acquire_pinned(g_tw_pool, g_dev, bytes_tabs)
-    unsafe {
-        upload_rows_padded(bx, addr(s.x[0]), npos, mp, d)
-        zero_rows(bk, npos, nk64, d)
-        gemma4v_pack_rope_tabs(s, npos, pairs, reinterpret<float?>(metal_buffer_contents(btabs)))
-    }
+    var ends = g4v_ends_make(t, s, npos, mp)
+    zero_rows(bk, npos, nk64, d)
+    gemma4v_pack_rope_tabs(s, npos, pairs, unsafe(reinterpret<float?>(metal_buffer_contents(btabs))))
     var u_d = uniform_u32(uint(d))
     var u_ff = uniform_u32(uint(ff))
     var u_hs = uniform_u32(uint(hs))
@@ -1289,6 +1855,7 @@ def private metal_gemma4v_blocks(t : Gemma4vTower; var s : Gemma4vState; npos :
         qoff = 0u, qrows = uint(mp), window = 0u, softcap = 0.0, hass = 0u, uend = uint(npos))
     var err = ""
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
+        g4v_stem_body(enc, t, ends, bblob, bwblob, bx, u_d, u_totd, mp, npos)
         for (l in range64(t.n_layer)) {
             let o = gemma4v_block_offs(t, l)
             let cb_q = uint64(o.clamp[GEMMA4V_GEMM_Q] * 4l)
@@ -1344,15 +1911,20 @@ def private metal_gemma4v_blocks(t : Gemma4vTower; var s : Gemma4vState; npos :
             pf_enc_rms(enc, bxb, 0ul, bw_fp, bxb, u_d, u_eps, npos)
             enc_add(enc, bx, 0ul, bxb, 0ul, u_totd, npos * d)
         }
+        g4v_tail_body(enc, t, ends, bblob, bwblob, bx, u_d, u_eps, u_in, u_out)
     }
     var served = false
     if (ran) {
-        unsafe {
-            memcpy(addr(s.x[0]), metal_buffer_contents(bx), uint64(npos * d * 4l))
+        if (!ends.tail) {   // with the tail on the device the soft tokens alone come back
+            unsafe {
+                memcpy(addr(s.x[0]), metal_buffer_contents(bx), uint64(npos * d * 4l))
+            }
         }
         tw_count_encode(npos, t.n_layer, false)
+        g_tower_convs++
         served = true
     }
+    g4v_ends_land(t, ends, ran, s)
     pool_release(g_tw_pool, bx, bytes_row)
     pool_release(g_tw_pool, bxb, bytes_row)
     pool_release(g_tw_pool, bxb2, bytes_row)
@@ -1382,9 +1954,76 @@ def private metal_gemma4v_blocks(t : Gemma4vTower; var s : Gemma4vState; npos :
 
 def private metal_tower_serves() : bool => g_tw_env_tower
 
+//! the gemma3v projector tail's device rows: the pooled rows, the soft tokens, the soft-norm's weight row
+struct private G3vTail {
+    on : bool           //!< the tail rides this encode's command buffer
+    n_side : int64      //!< the patch grid's side
+    nout : int64        //!< soft tokens: the pooled grid's rows
+    mpo : int64         //!< `nout` on the GEMM's 32-row lattice
+    bpool : MetalBuffer?
+    bout : MetalBuffer?
+    bsoft : MetalBuffer?
+    u_proj : MetalBuffer?
+    bytes_pool : uint64
+    bytes_out : uint64
+    bytes_soft : uint64
+}
+
+//! The tail rides the chain where the lever allows, its kernels compiled, its GEMM on the f32 tile's lattice (K a multiple
+//! of 32, N of 64) and the patch grid pools whole.
+def private g3v_tail_make(t : Gemma3vTower; npos : int64) : G3vTail {
+    let d = t.n_embd
+    let n_side = t.image_px / t.patch
+    var tl = G3vTail(n_side = n_side, nout = (n_side / t.merge) * (n_side / t.merge))
+    tl.on = (g_tw_tail && pf_tw_tail_ready() && d % 32l == 0l && t.proj_dim % 64l == 0l
+        && n_side * n_side == npos && n_side % t.merge == 0l)
+    return tl if (!tl.on)
+    tl.mpo = round_up(tl.nout, 32l)
+    tl.bytes_pool = uint64(tl.mpo * d * 4l)
+    tl.bytes_out = uint64(tl.mpo * t.proj_dim * 4l)
+    tl.bytes_soft = uint64(d * 4l)
+    tl.bpool = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_pool)
+    tl.bout = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_out)
+    zero_rows(tl.bpool, tl.nout, tl.mpo, d)   //! the pool writes the live rows alone and the projection reads the row pad: the buffers are pooled
+    tl.bsoft = pool_acquire_pinned(g_tw_pool, g_dev, tl.bytes_soft)
+    tl.u_proj = uniform_u32(uint(t.proj_dim))
+    unsafe(memcpy(metal_buffer_contents(tl.bsoft), plane_at(t.blob, t.soft_norm_w), tl.bytes_soft))
+    return tl
+}
+
+//! The CPU tail's four steps behind the blocks: the post-norm, the grid mean pool, the weighted rms, the projection.
+[arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-encode-chains")]
+def private g3v_tail_body(enc : MetalComputeEncoder?; t : Gemma3vTower; tl : G3vTail; bblob, bx, bs : MetalBuffer?;
+                          u_d, u_eps : MetalBuffer?; npos : int64) {
+    return if (!tl.on)
+    let d = t.n_embd
+    enc_ln(enc, bx, bblob, uint64(t.post_ln_w * 4l), bblob, uint64(t.post_ln_b * 4l), bs, 0ul, u_d, u_eps, npos)
+    enc_tw_pool2d(enc, bs, tl.bpool, TwPool2dArgs(width = uint(d), gw = uint(tl.n_side), k = uint(t.merge),
+        ow = uint(tl.n_side / t.merge), total = uint(tl.nout * d)), tl.nout * d)
+    pf_enc_rms(enc, tl.bpool, 0ul, tl.bsoft, tl.bpool, u_d, u_eps, tl.nout)
+    enc_f32_mm(enc, bblob, uint64(t.proj_w * 4l), tl.bpool, tl.bout, 0ul, u_d, tl.u_proj, tl.mpo, t.proj_dim)
+}
+
+//! the tail's soft tokens into `s.tail` where the command buffer ran, the CPU tail told to stand down; its buffers released
+def private g3v_tail_land(t : Gemma3vTower; var tl : G3vTail; ran : bool; var s : Gemma3vState) {
+    return if (!tl.on)
+    if (ran) {
+        ensure_length(s.tail, tl.nout * t.proj_dim)
+        unsafe {
+            memcpy(addr(s.tail[0]), metal_buffer_contents(tl.bout), uint64(tl.nout * t.proj_dim * 4l))
+        }
+        s.tail_ready = true
+        g_tower_tail_encodes++
+    }
+    pool_release(g_tw_pool, tl.bpool, tl.bytes_pool)
+    pool_release(g_tw_pool, tl.bout, tl.bytes_out)
+    pool_release(g_tw_pool, tl.bsoft, tl.bytes_soft)
+    pool_release(g_upool, tl.u_proj, 4ul)
+}
+
 // The gemma3v SigLIP block loop as ONE command buffer on the f32 blob — LN(w,b), biased f32 GEMMs,
 // scaled attention, GELU. The 72-wide heads restride to the attention tiles' 128 (zero pads exact,
-// scale stays 1/sqrt(72)); ffn serves at the layout's ff_pad. Stem/tail stay CPU; q8 declines.
+// scale stays 1/sqrt(72)); ffn serves at the layout's ff_pad. The tail rides the same command buffer (`g3v_tail_make`), the patch im2col stays CPU; q8 declines.
 [hot_path, arch(at="../ARCHITECTURE_IMAGE.md#image-tower-twin-plane"), arch(at="../ARCHITECTURE_GPU_TOWER.md#tower-attn-routes")]
 def private metal_gemma3v_blocks(t : Gemma3vTower; var s : Gemma3vState; npos : int64) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
     if (!g_tw_env_tower) {
@@ -1457,6 +2096,7 @@ def private metal_gemma3v_blocks(t : Gemma3vTower; var s : Gemma3vState; npos :
     var kaf = AttnArgs(qd = uint(d), kv_dim = uint(d), head_size = uint(hs), kv_mul = 1u,
         npos = uint(npos), np32 = uint(npos), scale = 1.0 / sqrt(float(hs)),
         qoff = 0u, qrows = uint(mp), window = 0u, softcap = 0.0, hass = 0u, uend = uint(npos))
+    var tl = g3v_tail_make(t, npos)
     var err = ""
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
         //! the stem: padded patch GEMM + conv bias + the learned positions (all row-aligned)
@@ -1502,15 +2142,19 @@ def private metal_gemma3v_blocks(t : Gemma3vTower; var s : Gemma3vState; npos :
             enc_add_bias_rows(enc, bxb2, 0ul, bblob, uint64(o.b[GEMMA3V_GEMM_DOWN] * 4l), u_d, u_totd, npos * d)
             enc_add(enc, bx, 0ul, bxb2, 0ul, u_totd, npos * d)
         }
+        g3v_tail_body(enc, t, tl, bblob, bx, bxb, u_d, u_eps, npos)
     }
     var served = false
     if (ran) {
-        unsafe {
-            memcpy(addr(s.x[0]), metal_buffer_contents(bx), uint64(npos * d * 4l))
+        if (!tl.on) {   // with the tail on the device the soft tokens alone come back: the block rows stay there
+            unsafe {
+                memcpy(addr(s.x[0]), metal_buffer_contents(bx), uint64(npos * d * 4l))
+            }
         }
         tw_count_encode(npos, t.n_layer, f16w)
         served = true
     }
+    g3v_tail_land(t, tl, ran, s)
     pool_release(g_tw_pool, bx, bytes_row)
     pool_release(g_tw_pool, bxb, bytes_row)
     pool_release(g_tw_pool, bxb2, bytes_row)
@@ -2008,20 +2652,64 @@ def private metal_qwen25v_blocks(t : Qwen25vTower; var s : Qwen25vState; npos :
     return true
 }
 
+var private g_tw_conv1_pad : St2SlabBase   //!< the served whisper-class tower's first conv with its columns zero-padded to the 32 lattice
+
+//! The first conv's weight rows at `k1` columns - the file's 3 x n_mel and zeros past them - on the device, once a tower:
+//! the im2col pass pads its rows to the same lattice with zeros. Null where the buffer cannot be made.
+[cold_path]
+def private tw_conv1_pad_attach(t : AudioTower; k1 : int64) : MetalBuffer? {
+    let key = hash_combine64(tw_plane_key(t.fblob), uint64(t.conv1_w_off))
+    return g_tw_conv1_pad.buf if (st2_slab_current(g_tw_conv1_pad, key))
+    st2_slab_free(g_tw_conv1_pad)
+    let d = t.d_model
+    let k = 3l * t.n_mel
+    var pad = metal_new_buffer(g_dev, uint64(d * k1 * 4l))
+    return null if (pad == null)
+    unsafe {
+        var p = reinterpret<float?>(metal_buffer_contents(pad))
+        for (r in range64(d)) {
+            for (c in range64(k1)) {
+                p[r * k1 + c] = c < k ? t.fblob[t.conv1_w_off + r * k + c] : 0.0
+            }
+        }
+    }
+    g_tw_conv1_pad.buf = pad
+    g_tw_conv1_pad.key = key
+    return pad
+}
+
+//! the stem's second conv as a GEMM over its im2col rows: the device q8 blob's region on a q8 tower, the f32 blob otherwise
+def private conv2_mm(enc : MetalComputeEncoder?; t : AudioTower; bblob, bx2, bx2h, bxo, u_3d, u_d : MetalBuffer?; mp2 : int64) {
+    let d = t.d_model
+    if (!t.q8) {
+        enc_f32_mm(enc, bblob, uint64(t.conv2_w_off * 4l), bx2, bxo, 0ul, u_3d, u_d, mp2, d)
+        return
+    }
+    if (bx2h != null) {
+        enc_cvt_half(enc, bx2, bx2h, mp2 * 3l * d)
+    }
+    pf_enc_q8_mm(enc, g_tw_q8.buf, g_tw_q8_conv2, bx2, bx2h, bxo, u_3d, u_d, mp2, d, 3l * d)
+}
+
 // The whisper conv frontend for one mel chunk: im2col + conv GEMMs + bias + GELU + pos-add,
 // one command buffer, s.x readback. BEST-EFFORT inside the tower knob: any decline is a
 // silent false (no counter noise — the CPU conv serves and the blocks still ride the GPU).
 [hot_path]
-def private metal_conv_frontend(t : AudioTower; var s : EncoderState; mel : MelChunk) : bool {
-    if (!g_tw_env_tower || t.q8) {
+def private metal_conv_frontend(t : AudioTower; var s : EncoderState; mel : MelChunk) : bool {   // nolint:STYLE038 — the dispatch chain is the shape
+    if (!g_tw_env_tower) {
         return false
     }
     let tin = AUDIO_CHUNK_FRAMES
     let tt = t.n_ctx
     let d = t.d_model
     let nm = t.n_mel
-    // tiny's 3x80 im2col width stays CPU; init re-arms after any shutdown seat
-    if ((3l * nm) % 32l != 0l || d % 64l != 0l || (3l * d) % 32l != 0l || !metal_tower_init()) {
+    // the first conv's 3 x n_mel columns ride the GEMM's 32 lattice: 80 mels' 240 pad to 256 through a padded weight copy
+    let k1 = round_up(3l * nm, 32l)
+    if (d % 64l != 0l || (3l * d) % 32l != 0l || !metal_tower_init() || (t.q8 && !tw_q8_attach(t))) {
+        return false
+    }
+    var bw1 = k1 == 3l * nm ? null : tw_conv1_pad_attach(t, k1)
+    if (k1 != 3l * nm && bw1 == null) {
         return false
     }
     let mp1 = round_up(tin, 32l)
@@ -2029,7 +2717,7 @@ def private metal_conv_frontend(t : AudioTower; var s : EncoderState; mel : MelC
     let mapped = t.image_map != null
     var bblob = plane_buffer(g_dev, unsafe(reinterpret<void?>(plane_at(t.fblob, 0l))), uint64(length(t.fblob) * 4l), mapped)
     let bytes_mel = uint64(nm * tin * 4l)
-    let bytes_x1 = uint64(mp1 * 3l * nm * 4l)
+    let bytes_x1 = uint64(mp1 * k1 * 4l)
     let bytes_y1 = uint64(mp1 * d * 4l)
     let bytes_x2 = uint64(mp2 * 3l * d * 4l)
     let bytes_xo = uint64(mp2 * d * 4l)
@@ -2038,20 +2726,25 @@ def private metal_conv_frontend(t : AudioTower; var s : EncoderState; mel : MelC
     var by1 = pool_acquire_pinned(g_tw_pool, g_dev, bytes_y1)
     var bx2 = pool_acquire_pinned(g_tw_pool, g_dev, bytes_x2)
     var bxo = pool_acquire_pinned(g_tw_pool, g_dev, bytes_xo)
+    var bx2h = (t.q8 && pf_q8_mm_half()) ? pool_acquire_pinned(g_tw_pool, g_dev, bytes_x2 / 2ul) : null
     unsafe {
         memcpy(metal_buffer_contents(bmel), addr(mel.data[0]), bytes_mel)
     }
-    var u_nm3 = uniform_u32(uint(3l * nm))
+    var u_nm3 = uniform_u32(uint(k1))
     var u_d = uniform_u32(uint(d))
     var u_3d = uniform_u32(uint(3l * d))
     var u_totd1 = uniform_u32(uint(tin * d))
     var u_totd2 = uniform_u32(uint(tt * d))
-    var k1 = St2ConvArgs(cin = uint(nm), k = 3u, stride = 1u, pad_l = 1u, dil = 1u, t_in = uint(tin), r0 = 0u, rows = uint(tin), xs = uint(nm))
+    var ka1 = St2ConvArgs(cin = uint(nm), k = 3u, stride = 1u, pad_l = 1u, dil = 1u, t_in = uint(tin), r0 = 0u, rows = uint(tin), xs = uint(nm))
     var k2 = St2ConvArgs(cin = uint(d), k = 3u, stride = 2u, pad_l = 1u, dil = 1u, t_in = uint(tin), r0 = 0u, rows = uint(tt), xs = uint(d))
     var err = ""
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
-        enc_st2_im2col_cm(enc, bmel, bx1, k1, mp1 * 3l * nm)
-        enc_f32_mm(enc, bblob, uint64(t.conv1_w_off * 4l), bx1, by1, 0ul, u_nm3, u_d, mp1, d)
+        enc_st2_im2col_cm(enc, bmel, bx1, ka1, mp1 * k1)
+        if (bw1 != null) {
+            enc_f32_mm(enc, bw1, 0ul, bx1, by1, 0ul, u_nm3, u_d, mp1, d)
+        } else {
+            enc_f32_mm(enc, bblob, uint64(t.conv1_w_off * 4l), bx1, by1, 0ul, u_nm3, u_d, mp1, d)
+        }
         enc_add_bias_rows(enc, by1, 0ul, bblob, uint64(t.conv1_b_off * 4l), u_d, u_totd1, tin * d)
         if (t.gelu_tanh) {
             enc_gelu_lut(enc, by1, 0ul, u_totd1, tin * d)
@@ -2059,7 +2752,7 @@ def private metal_conv_frontend(t : AudioTower; var s : EncoderState; mel : MelC
             enc_gelu_erf(enc, by1, 0ul, u_totd1, tin * d)
         }
         enc_st2_im2col(enc, by1, bx2, k2, mp2 * 3l * d)
-        enc_f32_mm(enc, bblob, uint64(t.conv2_w_off * 4l), bx2, bxo, 0ul, u_3d, u_d, mp2, d)
+        conv2_mm(enc, t, bblob, bx2, bx2h, bxo, u_3d, u_d, mp2)
         enc_add_bias_rows(enc, bxo, 0ul, bblob, uint64(t.conv2_b_off * 4l), u_d, u_totd2, tt * d)
         if (t.gelu_tanh) {
             enc_gelu_lut(enc, bxo, 0ul, u_totd2, tt * d)
@@ -2081,6 +2774,9 @@ def private metal_conv_frontend(t : AudioTower; var s : EncoderState; mel : MelC
     pool_release(g_tw_pool, by1, bytes_y1)
     pool_release(g_tw_pool, bx2, bytes_x2)
     pool_release(g_tw_pool, bxo, bytes_xo)
+    if (bx2h != null) {
+        pool_release(g_tw_pool, bx2h, bytes_x2 / 2ul)
+    }
     pool_release(g_upool, u_nm3, 4ul)
     pool_release(g_upool, u_d, 4ul)
     pool_release(g_upool, u_3d, 4ul)
@@ -2325,9 +3021,10 @@ def private metal_q3a_mel(xw : array<float>; n_len, n_fft, n_bins, n_mel : int64
     var u_totm = uniform_u32(uint(n_len * n_mel))
     var err = ""
     let ran = with_compute_encoder(g_queue, err) $(enc : MetalComputeEncoder?) {   // nolint:PERF026 — the error-text fetch runs only on the failure leg
-        enc_f32_mm(enc, btw, 0ul, bxw, bre, 0ul, u_kfp, u_dft_out_pad, mp, dft_out_pad)
+        // the float tiles: a quiet bin sits 80 dB under the frame's loud ones, below what a half tile resolves
+        enc_f32_exact_mm(enc, btw, 0ul, bxw, bre, 0ul, u_kfp, u_dft_out_pad, mp, dft_out_pad)
         enc_q3a_pow(enc, bre, bpow, u_nbins, u_dft_out_pad, u_ldpow, u_totpow, mp * ldpow)
-        enc_f32_mm(enc, bfil, 0ul, bpow, braw, 0ul, u_ldpow, u_nmel, mp, n_mel)
+        enc_f32_exact_mm(enc, bfil, 0ul, bpow, braw, 0ul, u_ldpow, u_nmel, mp, n_mel)
         enc_q3a_logmel_t(enc, braw, bout, u_nmel, u_nlen, u_floor, u_scale, u_totm, n_len * n_mel)
     }
     var served = false
@@ -2335,6 +3032,7 @@ def private metal_q3a_mel(xw : array<float>; n_len, n_fft, n_bins, n_mel : int64
         unsafe {
             memcpy(addr(m.data[0]), metal_buffer_contents(bout), uint64(n_mel * n_len * 4l))
         }
+        g_tower_mels++
         served = true
     }
     pool_release(g_tw_pool, bxw, bytes_xw)
@@ -4514,6 +5212,9 @@ def private metal_styletts2_driver : St2GpuDriver {
 def private tw_weights_drop {
     st2_slab_free(g_tw_q3a_wpad)
     st2_slab_free(g_tw_fc_twin)
+    st2_slab_free(g_tw_q8)
+    st2_slab_free(g_tw_conv1_pad)
+    st2_slab_free(g_tw_cn_front)
     st2_slab_drop()
 }
 
@@ -4533,17 +5234,20 @@ def dasllama_metal_tower_register {
         to_log(LOG_INFO, "dasLLAMA metal tower: DASLLAMA_METAL_TOWER_FLASH=0 - the dk72 one-pass attention stays off, the slab trio serves\n")
     }
     register_gemma4uv_gpu(@@metal_gemma4uv_encode)
-    register_gemma4v_gpu(@@metal_gemma4v_blocks, @@metal_tower_serves)
+    register_gemma4v_gpu(@@metal_gemma4v_blocks, @@metal_tower_serves, true)
     register_gemma3v_gpu(@@metal_gemma3v_blocks, @@metal_tower_serves)
     register_qwen3v_gpu(@@metal_qwen3v_blocks, @@metal_tower_serves)
     register_qwen25v_gpu(@@metal_qwen25v_blocks)
     register_tower_blocks_gpu(@@metal_tower_blocks, @@metal_tower_serves)
+    register_tower_blocks_ln_post_gpu(@@metal_tower_blocks_ln_post)
+    register_tower_blocks_tail_gpu(@@metal_tower_blocks_tail)
     register_tower_conv_gpu(@@metal_conv_frontend)
     register_qwen3a_front_gpu(@@metal_q3a_front)
-    register_qwen3a_mel_gpu(@@metal_q3a_mel)
+    register_whisper_mel_gpu(@@metal_q3a_mel)
     register_gemma4a_gpu(@@metal_gemma4a_blocks, @@metal_tower_serves)
     register_gemma4a_chunk_gpu(@@metal_gemma4a_chunk)
     register_canary_gpu(@@metal_canary_blocks, @@metal_tower_serves)
+    register_canary_front_gpu(@@metal_canary_front)
     register_parakeet_gpu(@@metal_parakeet_blocks, @@metal_tower_serves)
     register_parakeet_gpu_encode(@@metal_parakeet_encode)
     register_styletts2_gpu(metal_styletts2_driver())
diff --git a/modules/dasLLAMA/dasllama/dasllama_parakeet.das b/modules/dasLLAMA/dasllama/dasllama_parakeet.das
index cb7696f64b..5182ef6da5 100644
--- a/modules/dasLLAMA/dasllama/dasllama_parakeet.das
+++ b/modules/dasLLAMA/dasllama/dasllama_parakeet.das
@@ -426,7 +426,7 @@ def private pk_fold_bn(var blob : array<float>; w, b, mean, vr, d : int64) {
 // ===== bin container =====
 
 // whisper-bin-style tensor records: i32 n_dims, i32 name_len, i32 ftype; i32 dims (ne
-// order); name bytes; raw data (f32/f16), unaligned.
+// order); name bytes; raw data (f32, f16 or Q8_0 blocks), unaligned.
 struct private PkTensorRec {
     ttype : int
     n_elem : int64
@@ -453,15 +453,7 @@ def private pk_read(recs : table<string; PkTensorRec>; b : array<uint8> | #; nam
     if (r.n_elem != n) {
         panic("dasLLAMA parakeet: tensor '{name}' has {r.n_elem} elements, want {n}")
     }
-    if (r.ttype == GGML_TYPE_F32) {
-        for (i in range64(n)) {
-            dst[dst_off + i] = rd_f32(b, r.off + i * 4l)
-        }
-    } else {
-        for (i in range64(n)) {
-            dst[dst_off + i] = f16_to_f32(rd_u16(b, r.off + i * 2l))
-        }
-    }
+    ggml_bin_read_f32(b, r.ttype, r.off, n, dst, dst_off)
 }
 
 // GEMM weight read: a q8 load transcodes it from the file straight into qblob/qscales at its
@@ -649,7 +641,7 @@ def stage_parakeet_model(path : string; q8 : bool = false) : ParakeetStaging {
             let name = pk_bytes_str(bytes, o, name_len)
             o += name_len
             recs[name] = PkTensorRec(ttype = ttype, n_elem = n_elem, off = o)
-            o += n_elem * (ttype == GGML_TYPE_F32 ? 4l : 2l)
+            o += ggml_bin_tensor_bytes(ttype, n_elem)
         }
 
         // blob layout — dual walk: `bo` is the full layout (qblob on a q8 load, blob on an
diff --git a/modules/dasLLAMA/dasllama/dasllama_prefix.das b/modules/dasLLAMA/dasllama/dasllama_prefix.das
index fcba27333f..149b8d35d7 100644
--- a/modules/dasLLAMA/dasllama/dasllama_prefix.das
+++ b/modules/dasLLAMA/dasllama/dasllama_prefix.das
@@ -321,6 +321,37 @@ def prefix_attach_(var cache : PrefixCache; var pool : KVPool; var s : Session;
     return matched
 }
 
+//! How many leading positions of `prompt` `prefix_attach_` would attach right now, with nothing attached and no entry
+//! touched: the whole pages the cache holds, then the rows the page past them shares. 0 on a recurrent model's cache,
+//! which attaches at checkpoints - a caller that needs the count there treats nothing as held.
+def prefix_match_len_(cache : PrefixCache; pool : KVPool; prompt : array<int64>) : int64 {
+    return 0l if (!empty(cache.states))
+    let np = long_length(prompt)
+    let pr = pool.page_rows
+    let pages_max = np > 0l ? (np - 1l) / pr : 0l
+    var hit_hash = 0ul
+    var matched = 0l
+    for (i in range64(pages_max)) {
+        let nh = chain_page_hash(hit_hash, prompt, i * pr, (i + 1l) * pr)
+        break if (!key_exists(cache.entries, nh))
+        let e = unsafe(cache.entries?[nh])
+        break if (e == null || long_length(e.tokens) != pr || !page_tokens_match(*e, prompt, i * pr))
+        hit_hash = nh
+        matched += pr
+    }
+    var rows = 0l
+    if (matched > 0l) {
+        for (key in unsafe(cache.entries?[hit_hash]).nexts) {
+            rows = max(rows, shared_rows(cache, key, prompt, matched))
+        }
+    } else {
+        for (key in cache.roots) {
+            rows = max(rows, shared_rows(cache, key, prompt, matched))
+        }
+    }
+    return matched + rows
+}
+
 // Drop the least-recently-used entry (release its group hold + its chain's live count).
 def private prefix_evict_lru(var cache : PrefixCache; var pool : KVPool) {
     var lru_key = 0ul
diff --git a/modules/dasLLAMA/dasllama/dasllama_qwen3a.das b/modules/dasLLAMA/dasllama/dasllama_qwen3a.das
index 1a6ccdf505..0d0a46af01 100644
--- a/modules/dasLLAMA/dasllama/dasllama_qwen3a.das
+++ b/modules/dasLLAMA/dasllama/dasllama_qwen3a.das
@@ -163,18 +163,6 @@ def private q3a_announce_lane() {
     to_log(LOG_INFO, "dasLLAMA qwen3a: tower GEMM lane {q3a_serve_q8() ? "q8" : "f32 planes"} - {why}\n")
 }
 
-[arch(at="../ARCHITECTURE_IMAGE.md#image-tower-twin-plane")]
-def private q3a_gemm_types_uniform(m : GGUFMeta; n_layer : int64; gt : int) : bool {
-    for (l in range64(n_layer)) {
-        for (nm in ["attn_q", "attn_k", "attn_v", "attn_out", "ffn_up", "ffn_down"]) {
-            if (gguf_tensor_type(m, "a.blk.{l}.{nm}.weight") != gt) {
-                return false
-            }
-        }
-    }
-    return true
-}
-
 //! Load a Qwen3-ASR mmproj GGUF (projector type `qwen3a`, bf16/f16/f32 tensors). Like
 //! ``load_model``, caches a box/knob-specific PREPARED IMAGE for fast reload;
 //! ``DASLLAMA_IMAGE=0`` disables it, a ``.dlim`` path loads one directly.
@@ -287,7 +275,7 @@ def stage_qwen3a_tower(path : string) : Qwen3aStaging {
         st.e.core <- c
         if (q3a_serve_q8()) {
             tower_quantize(st.e.core, st.core)   // arm the shared core's q8 rail (encoder_blocks reads core.q8)
-        } elif ((gt == GGML_TYPE_BF16 || gt == GGML_TYPE_F16) && q3a_gemm_types_uniform(m, st.e.core.n_layer, gt)) {
+        } elif ((gt == GGML_TYPE_BF16 || gt == GGML_TYPE_F16) && tower_gemm_types_uniform(m, st.e.core.n_layer, gt)) {
             tower_bake_half_twin(st.core.fblob, st.core.wblob, st.e.core.blk_bf16)
         }
 
@@ -384,18 +372,6 @@ def private q3a_cblob_quantize(var t : Qwen3aTower; var cblob : array<float>; va
     tw_repack(qblob, qscales, t.mm2_w_off, d, t.proj_dim)
 }
 
-//! the GPU mel hook: DFT/power/mel off the CPU-windowed xw frames into m.data
-typedef Qwen3aMelGpuFn = function<(xw : array<float>; n_len, n_fft, n_bins, n_mel : int64;
-                                   twiddles, filters : array<float>; var m : WhisperMel) : bool>
-var private g_q3a_mel_gpu : Qwen3aMelGpuFn
-var private g_q3a_mel_gpu_set = false
-
-[arch(at="../ARCHITECTURE_MEDIA.md#tower-gpu-hook")]
-def register_qwen3a_mel_gpu(fn : Qwen3aMelGpuFn) {
-    g_q3a_mel_gpu = fn
-    g_q3a_mel_gpu_set = true
-}
-
 //! Qwen3-ASR's log-mel (WhisperFeatureExtractor, center=True, truncation=False): 200-sample
 //! reflection pad both ends, NO 30s zero tail, clamp max stays in double (unlike the mtmd flavor,
 //! no float round-trip); n_len = min((n_padded−400)/160+1, n_in/160+1), mel-major.
@@ -403,7 +379,7 @@ def log_mel_qwen3a(samples : array<float> | #; n_mel : int64) : WhisperMel {
     let n_in = long_length(samples)
     let head = AUDIO_N_FFT / 2l                        // 200 reflection each side
     let n_padded = n_in + 2l * head
-    var padded : array<float>
+    var inscope padded : array<float>
     padded |> reserve_resize(int(n_padded))
     for (i in range(int(n_in))) {
         padded[int(head) + i] = samples[i]
@@ -425,11 +401,11 @@ def log_mel_qwen3a(samples : array<float> | #; n_mel : int64) : WhisperMel {
     m.n_len_org = m.n_len
     m.data |> reserve_resize(int(n_mel * m.n_len))
 
-    let hann <- build_hann_window(n_fft)
-    let twiddles <- build_dft_twiddles(n_fft)
-    let filters <- build_mel_filterbank(n_mel, n_fft, AUDIO_SAMPLE_RATE)
+    var inscope hann <- build_hann_window(n_fft)
+    var inscope twiddles <- build_dft_twiddles(n_fft)
+    var inscope filters <- build_mel_filterbank(n_mel, n_fft, AUDIO_SAMPLE_RATE)
 
-    var xw : array<float>
+    var inscope xw : array<float>
     xw |> reserve_resize(int(m.n_len * n_fft))
     for (i in range64(m.n_len)) {
         let off = i * AUDIO_HOP
@@ -438,9 +414,9 @@ def log_mel_qwen3a(samples : array<float> | #; n_mel : int64) : WhisperMel {
             xw[i * n_fft + j] = hann[j] * padded[off + j]
         }
     }
-    let mel_on_gpu = g_q3a_mel_gpu_set && invoke(g_q3a_mel_gpu, xw, m.n_len, n_fft, n_bins, n_mel, twiddles, filters, m)
+    let mel_on_gpu = whisper_mel_gpu(xw, m.n_len, n_fft, n_bins, n_mel, twiddles, filters, m)
     if (!mel_on_gpu) {
-        var reim : array<float>
+        var inscope reim : array<float>
         reim |> reserve_resize(int(m.n_len * n_bins * 2l))
         gemm_f32(unsafe(addr(reim[0])), unsafe(addr(xw[0])), unsafe(addr(twiddles[0])),
                  m.n_len, n_fft, n_bins * 2l)
@@ -449,7 +425,7 @@ def log_mel_qwen3a(samples : array<float> | #; n_mel : int64) : WhisperMel {
         // double (reference-exact rounding), floor 2^-24, log10
         let mel_floor = 5.960464477539063e-08lf
         let log10_e = 0.43429448190325176lf
-        var power : array<float>
+        var inscope power : array<float>
         power |> resize(int(n_bins))
         for (i in range64(m.n_len)) {
             for (k in range64(n_bins)) {
@@ -663,7 +639,7 @@ def qwen3a_encode_all(t : Qwen3aTower; var s : EncoderState; var cs : Qwen3aConv
     var total = 0l
     var off = 0l
     while (off < mel.n_len) {
-        let win <- qwen3a_mel_window(mel, off)
+        var inscope win <- qwen3a_mel_window(mel, off)
         qwen3a_encode(t, s, cs, win)
         let n = (win.n_len / QWEN3A_CHUNK) * QWEN3A_TOK_PER_CHUNK
         rows |> reserve(long_length(rows) + n * t.proj_dim)
@@ -720,20 +696,20 @@ def qwen3a_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession; co
                       samples : array<float> | #; blk : block<(seg : TranscribeSegment)>;
                       var detected_lang : string&) : int {
     let tprof = ref_time_ticks()
-    let mel <- log_mel_qwen3a(samples, t.core.n_mel)
+    var inscope mel <- log_mel_qwen3a(samples, t.core.n_mel)
     asr_prof_add("q3a.mel", tprof)
-    var rows : array<float>
+    var inscope rows : array<float>
     let n_audio = qwen3a_encode_all(t, s.qenc, s.qcs, mel, rows)
     asr_prof_add("q3a.encode", tprof)
 
     let dim = dec.config.dim
     let im_start = special_id(dec, "<|im_start|>")
     let im_end = special_id(dec, "<|im_end|>")
-    var head : array<int64>
+    var inscope head : array<int64>
     head |> push(im_start)
     head |> push_from(encode_(dec, "user\n", false, false))
     head |> push(special_id(dec, "<|audio_start|>"))
-    var tail : array<int64>
+    var inscope tail : array<int64>
     tail |> push(special_id(dec, "<|audio_end|>"))
     if (!empty(context)) {
         tail |> push_from(encode_(dec, context, false, false))
@@ -746,26 +722,21 @@ def qwen3a_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession; co
     let n_head = long_length(head)
     let n_tail = long_length(tail)
     let npos = n_head + n_audio + n_tail
-    var embd : array<float>
-    embd |> reserve_resize(int(npos * dim))
-    embed_text_rows(dec, head, embd, 0l)
-    for (i in range64(n_audio * dim)) {
-        embd[n_head * dim + i] = rows[i]
-    }
-    embed_text_rows(dec, tail, embd, n_head + n_audio)
+    var inscope embd : array<float>
+    media_body_rows_(dec, s.qctx, head, rows, n_audio, dim, tail, embd)
 
     s.qctx.n_past = 0l   // each transcribe is a fresh sequence; the KV rewinds to position 0
     var tp = ref_time_ticks()
-    eval_embd_(dec, s.qctx, embd, npos)
+    eval_embd_body_(dec, s.qctx, embd, npos, 0l, 0l, int2(0))
     asr_prof_add("q3a.prefill", tp)
 
     let eot = special_id(dec, "<|endoftext|>")
     let max_new = dec.config.seq_len - npos - 1l
-    var one : array<int64>
+    var inscope one : array<int64>
     one |> resize(1)
-    var toks : array<int>
+    var inscope toks : array<int>
     var plog_sum = 0.0lf
-    var raw : array<string>
+    var inscope raw : array<string>
     tp = ref_time_ticks()
     for (_i in range64(max_new)) {
         let ti = ref_time_ticks()
@@ -796,7 +767,7 @@ def qwen3a_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession; co
         }
         text = slice(full, mark + length("<asr_text>"), length(full))
     }
-    var seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE, text = text)
+    var inscope seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE, text = text)
     seg.tokens := toks
     if (!empty(toks)) {
         seg.avg_logprob = float(plog_sum / double(length(toks) + 1))   // + the stop token's plog
@@ -811,19 +782,19 @@ def qwen3a_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession; co
 def qwen3omni_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession;
                          samples : array<float> | #; blk : block<(seg : TranscribeSegment)>) : int {
     let tp = ref_time_ticks()
-    let mel <- log_mel_qwen3a(samples, t.core.n_mel)
-    var arows : array<float>
+    var inscope mel <- log_mel_qwen3a(samples, t.core.n_mel)
+    var inscope arows : array<float>
     let n_audio = qwen3a_encode_all(t, s.qenc, s.qcs, mel, arows)
     asr_prof_add("q3o.encode", tp)
 
     let dim = dec.config.dim
     let im_start = special_id(dec, "<|im_start|>")
     let im_end = special_id(dec, "<|im_end|>")   // = the EOG (151645)
-    var head : array<int64>
+    var inscope head : array<int64>
     head |> push(im_start)
     head |> push_from(encode_(dec, "user\n", false, false))
     head |> push(special_id(dec, "<|audio_start|>"))
-    var tail : array<int64>
+    var inscope tail : array<int64>
     tail |> push(special_id(dec, "<|audio_end|>"))
     tail |> push_from(encode_(dec, "Transcribe the audio.", false, false))
     tail |> push(im_end)
@@ -834,24 +805,19 @@ def qwen3omni_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession;
     let n_head = long_length(head)
     let npos = n_head + n_audio + long_length(tail)
     asr_ctx_guard(n_audio, npos, dec.config.seq_len)
-    var embd : array<float>
-    embd |> reserve_resize(int(npos * dim))
-    embed_text_rows(dec, head, embd, 0l)
-    for (i in range64(n_audio * dim)) {
-        embd[n_head * dim + i] = arows[i]
-    }
-    embed_text_rows(dec, tail, embd, n_head + n_audio)
+    var inscope embd : array<float>
+    media_body_rows_(dec, s.qctx, head, arows, n_audio, dim, tail, embd)
 
     s.qctx.n_past = 0l   // fresh sequence per transcribe
     let td = ref_time_ticks()
-    eval_embd_(dec, s.qctx, embd, npos)
+    eval_embd_body_(dec, s.qctx, embd, npos, 0l, 0l, int2(0))
 
     let eot = special_id(dec, "<|endoftext|>")
     let max_new = dec.config.seq_len - npos - 1l
-    var one : array<int64>
+    var inscope one : array<int64>
     one |> resize(1)
-    var toks : array<int>
-    var raw : array<string>
+    var inscope toks : array<int>
+    var inscope raw : array<string>
     toks |> reserve(256)
     raw |> reserve(256)
     for (_i in range64(max_new)) {
@@ -871,7 +837,7 @@ def qwen3omni_transcribe(dec : Model; t : Qwen3aTower; var s : Qwen3aAsrSession;
     }
     asr_prof_add("q3o.decode", td)
 
-    var seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE,
+    var inscope seg = TranscribeSegment(t0 = 0l, t1 = long_length(samples) * 100l / AUDIO_SAMPLE_RATE,
         text = strip(join(raw, "")))
     seg.tokens := toks
     blk |> invoke(seg)
diff --git a/modules/dasLLAMA/dasllama/dasllama_sampling.das b/modules/dasLLAMA/dasllama/dasllama_sampling.das
index 60fe6336bf..eaeb5adfce 100644
--- a/modules/dasLLAMA/dasllama/dasllama_sampling.das
+++ b/modules/dasLLAMA/dasllama/dasllama_sampling.das
@@ -328,13 +328,7 @@ def generate_embd_(t : Model; var s : Session; embd : array<float>; npos : int64
                    blk : block<(id : int64; piece : string) : bool>) : int64 {
     s.recent |> clear()
     let t_pre = ref_time_ticks()
-    if (span_hi > span_lo && grid.x > 0) {
-        eval_embd_span_mrope_(t, s, embd, npos, span_lo, span_hi, int64(grid.x), int64(grid.y))
-    } elif (span_hi > span_lo) {
-        eval_embd_span_(t, s, embd, npos, span_lo, span_hi)
-    } else {
-        eval_embd_(t, s, embd, npos)
-    }
+    eval_embd_body_(t, s, embd, npos, span_lo, span_hi, grid)
     s.stat_prefill_us = int64(get_time_usec(t_pre))
     s.stat_n_prefill = npos
     var one : array<int64>
diff --git a/modules/dasLLAMA/dasllama/dasllama_scheduler.das b/modules/dasLLAMA/dasllama/dasllama_scheduler.das
index 6605e54b50..91dd93b8c2 100644
--- a/modules/dasLLAMA/dasllama/dasllama_scheduler.das
+++ b/modules/dasLLAMA/dasllama/dasllama_scheduler.das
@@ -43,6 +43,18 @@ struct SchedEvent {
     gen_us : int64 = 0l                     // finished: first sampled token -> finish (microseconds)
 }
 
+//! One media span of a prompt: `n` positions from prompt index `at`, each entry a `media_position_id` of the media's
+//! content key, so the prefix cache matches across the span as across text. `rows` are the span's soft tokens (dim-wide
+//! audio, dim*(1+n_deepstack)-wide images); a request leaves them empty for a span it counts on the cache to hold.
+struct MediaSpan {
+    at : int64
+    n : int64
+    non_causal : bool                       // the rows attend each other in full (an image span); audio is causal
+    grid : int2                             // qwen mrope: the merged image grid roping the rows; (0,0) = sequential positions
+    rows : array<float>
+    done : bool                             // the span's K/V stands: attached off the prefix cache, or evaled
+}
+
 //! A parsed + rendered request awaiting admission: tokens only, NO session — queued requests hold
 //! no KV memory. The caller renders (create_chat_renderer / render_assistant / render_turn, or a
 //! raw encode) and assigns unique ids.
@@ -65,6 +77,7 @@ struct PendingReq {
     media_at : int64                        // prompt index the rows splice at (0 <= media_at <= |prompt|)
     media_non_causal : bool                 // the rows attend each other in full (gemma vision); audio is causal
     media_grid : int2                       // qwen mrope: the merged image grid (nx, ny) roping the rows; (0,0) = sequential positions (gemma, audio)
+    spans : array<MediaSpan>                //! media already INLINE in `prompt` as position ids (a transcript renderer's form); `submit` folds the splice fields above into one
 }
 
 //! One active generation stream: the owned KV session plus its request state. Managed wholly by
@@ -77,13 +90,9 @@ struct Stream {
     close_toks : array<int64>
     stop_ids : array<int64>
     nothink : NothinkStopGuard = NothinkStopGuard()
-    n_prefilled : int64                     // prompt tokens evaled so far
-    media_embd : array<float>               // the splice's soft-token rows (see PendingReq)
-    n_media : int64
-    media_at : int64
-    media_non_causal : bool
-    media_grid : int2
-    media_done : bool                       // the rows have been evaled (their own prefill quantum)
+    n_prefilled : int64                     // prompt positions whose K/V stands: attached or evaled
+    spans : array<MediaSpan>                // the prompt's media spans, in prompt order (see PendingReq)
+    n_media : int64                         // media positions in the prompt, every span's
     max_new : int64
     n_gen : int64                           // tokens emitted so far
     cur_tok : int64 = -1l                   // sampled but not yet evaled — the next decode step's input
@@ -174,6 +183,8 @@ struct Scheduler {
     batch_idx : array<int64>                // batch row -> streams index
     mtp_acc : array<int64>                  // the joint speculative tick's answer per batch row: the accepted draft, or -1
     chunk : array<int64>                    // the current prefill chunk
+    chunk_tail : array<int64>               // a media body's text past its span
+    @exact_size body : array<float>         // a media body's rows
     donate_toks : array<int64>              // reap-time scratch: tail eval + the insert token list
     // counters (/v1/stats and server_bench read these)
     n_admitted : int64
@@ -187,6 +198,7 @@ struct Scheduler {
     cached_tokens : int64                   // prefix-cache hits (tokens attached instead of prefilled)
     recent_done : array<DoneStream>         // finished-stream linger for the poll surface (~10 s)
     prefill_tokens : int64                  // prompt tokens actually computed (cache hits excluded)
+    prefill_evals : int64                   // prefill calls those tokens took
     ttft_sum_us : int64                     // Σ ttft over reaped streams that produced a token
     ttft_count : int64
     last_ttft_us : int64                    // most recently reaped stream's ttft
@@ -218,6 +230,7 @@ def create_scheduler(model : Model; max_streams : int64 = 4l; max_queue : int64
     if (page_rows > 0l) {
         sch.paged = true
         sch.pool <- create_kv_pool(model, page_rows, kv_dtype)
+        kv_pool_reserve(sch.pool, sch.max_streams * (model.config.seq_len + page_rows) + prefix_groups * page_rows)
         sch.prefix <- create_prefix_cache(prefix_groups, prefix_states)
     }
     return <- sch
@@ -253,6 +266,50 @@ def private mtp_totals(sch : Scheduler) : tuple<drafted : int64; accepted : int6
 //! Queued (not yet admitted) request count.
 def n_queued(sch : Scheduler) : int64 => long_length(sch.queue)
 
+//! A splice request as an inline span: the rows' position ids enter the prompt at the splice, keyed by the rows' own
+//! bytes, so a caller that hands rows with no key still shares a prefix with a request carrying the same rows.
+def splice_to_span(var req : PendingReq) {
+    var key = 0x9e3779b97f4a7c15ul
+    for (v in req.media_embd) {
+        key = hash_combine64(key, uint64(unsafe(reinterpret<uint>(v))))
+    }
+    var inscope tail <- [for (i in range64(req.media_at, long_length(req.prompt))); req.prompt[i]]
+    req.prompt |> resize(req.media_at)
+    req.prompt |> reserve(req.media_at + req.n_media + long_length(tail))
+    for (r in range64(req.n_media)) {
+        req.prompt |> push(media_position_id(key, r))
+    }
+    req.prompt |> push_from(tail)
+    req.spans |> emplace(MediaSpan(at = req.media_at, n = req.n_media, non_causal = req.media_non_causal,
+                                   grid = req.media_grid, rows <- req.media_embd))
+    req.n_media = 0l
+    req.media_at = 0l
+    req.media_non_causal = false
+    req.media_grid = int2(0)
+}
+
+//! a request's inline spans: in prompt order, over position ids, each with rows of the model's width or none
+def private check_spans(model : Model; sch : Scheduler; req : PendingReq) {
+    return if (empty(req.spans))
+    if (sch.device_kv) {
+        panic("dasllama_scheduler: a media request in device mode (stream {req.id}) - a device-home session serves no media span; the wiring keeps `set_device_kv` off for a model that takes media")
+    }
+    var floor = 0l
+    for (sp in req.spans) {
+        if (sp.n <= 0l || sp.at < floor || sp.at + sp.n > long_length(req.prompt)) {
+            panic("dasllama_scheduler: media span [{sp.at}, {sp.at + sp.n}) outside the {length(req.prompt)}-position prompt or out of order (stream {req.id})")
+        }
+        if (!is_media_position(req.prompt[sp.at]) || !is_media_position(req.prompt[sp.at + sp.n - 1l])) {
+            panic("dasllama_scheduler: media span [{sp.at}, {sp.at + sp.n}) does not stand on position ids (stream {req.id})")
+        }
+        let need = sp.n * model.config.dim * (1l + (sp.non_causal ? model.config.n_deepstack : 0l))
+        if (!empty(sp.rows) && long_length(sp.rows) != need) {
+            panic("dasllama_scheduler: a {sp.n}-row media span needs {need} floats, got {length(sp.rows)} (stream {req.id})")
+        }
+        floor = sp.at + sp.n
+    }
+}
+
 //! Queue a request; false = queue full (the wiring answers 503). Preconditions PANIC — the wiring
 //! must reject them first (its 400s): a non-empty prompt that fits the model context with room to
 //! generate, and max_new >= 1.
@@ -292,8 +349,15 @@ def submit(model : Model; var sch : Scheduler; var req : PendingReq) : bool {
     } elif (long_length(req.media_embd) != 0l || req.media_at != 0l || req.media_grid != int2(0)) {
         panic("dasllama_scheduler: media rows, media_at, or media_grid set with n_media == 0 (stream {req.id}) - the rows would be silently dropped")
     }
-    if (np + req.n_media + 1l > model.config.seq_len) {
-        panic("dasllama_scheduler: {np + req.n_media}-position prompt does not fit seq_len {model.config.seq_len} (stream {req.id}) - the wiring must reject it first")
+    if (req.n_media > 0l) {
+        if (!empty(req.spans)) {
+            panic("dasllama_scheduler: a request with both a media splice and inline spans (stream {req.id})")
+        }
+        splice_to_span(req)
+    }
+    check_spans(model, sch, req)
+    if (long_length(req.prompt) + 1l > model.config.seq_len) {
+        panic("dasllama_scheduler: {length(req.prompt)}-position prompt does not fit seq_len {model.config.seq_len} (stream {req.id}) - the wiring must reject it first")
     }
     if (req.max_new < 1l) {
         panic("dasllama_scheduler: max_new {req.max_new} < 1 (stream {req.id}) - the wiring must clamp it first")
@@ -317,7 +381,7 @@ def private finish_stream(var st : Stream; finish : string; var events : array<S
     let rate = gen_us > 0l ? 1000000.0 * float(st.n_gen) / float(gen_us) : 0.0
     to_log(LOG_INFO, "[stream {st.id}] finish: reason={finish}, gen={st.n_gen} tok in {gen_us / 1000l}ms ({rate} tok/s), total {int64(get_time_usec(st.t_admit)) / 1000l}ms\n")
     events |> push(SchedEvent(stream = st.id, kind = SchedEventKind.finished, finish = finish,
-                              n_prompt = long_length(st.prompt) + st.n_media, n_gen = st.n_gen,
+                              n_prompt = long_length(st.prompt), n_gen = st.n_gen,
                               n_cached = st.n_cached, ttft_us = st.ttft_us,
                               gen_us = gen_us))
 }
@@ -415,7 +479,7 @@ def evict(var sch : Scheduler; id : int64; var events : array<SchedEvent>) : boo
     for (i in range64(long_length(sch.queue))) {
         if (sch.queue[i].id == id) {
             events |> push(SchedEvent(stream = id, kind = SchedEventKind.finished, finish = "evicted",
-                                      n_prompt = long_length(sch.queue[i].prompt) + sch.queue[i].n_media))
+                                      n_prompt = long_length(sch.queue[i].prompt)))
             delete sch.queue[i]   // erase is a raw memmove — finalize the owned arrays first
             sch.queue |> erase(i)
             sch.n_evicted ++
@@ -446,10 +510,7 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
                          params = sch.queue[0].params, prompt <- sch.queue[0].prompt,
                          close_toks <- sch.queue[0].close_toks, stop_ids <- sch.queue[0].stop_ids,
                          nothink <- sch.queue[0].nothink,
-                         media_embd <- sch.queue[0].media_embd, n_media = sch.queue[0].n_media,
-                         media_at = sch.queue[0].media_at,
-                         media_non_causal = sch.queue[0].media_non_causal,
-                         media_grid = sch.queue[0].media_grid,
+                         spans <- sch.queue[0].spans,
                          max_new = sch.queue[0].max_new, t_admit = ref_time_ticks())
         if (sch.device_kv) {
             st.session <- create_device_session(m, gpu_device_session_dtype())
@@ -458,14 +519,16 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
             st.n_cached = matched
             sch.cached_tokens += matched
             to_log(LOG_INFO, "[stream {st.id}] device prefix: {matched}/{length(st.prompt)} tok already on the device\n")
-        } elif (sch.paged && st.n_media > 0l) {
-            // a media stream's KV past the splice does NOT follow from its token ids, so neither
-            // half of the prefix cache is sound for it: no attach here, no donate at reap
-            st.session <- create_session(m, sch.pool)
-            to_log(LOG_INFO, "[stream {st.id}] prefix cache BYPASSED: {st.n_media} media rows splice at token {st.media_at}\n")
         } elif (sch.paged) {
             st.session <- create_session(m, sch.pool)
-            let matched = prefix_attach(sch.prefix, sch.pool, st.session, st.prompt)
+            var matched = prefix_attach(sch.prefix, sch.pool, st.session, st.prompt)
+            if (cuts_a_span(st.spans, matched)) {   // a span evals whole: a hit that ends inside one is no hit
+                release_kv_pages(st.session)
+                delete st.session
+                st.session <- create_session(m, sch.pool)
+                matched = 0l
+            }
+            adopt_spans(st, matched)
             st.n_prefilled = matched
             st.n_cached = matched
             sch.cached_tokens += matched
@@ -481,14 +544,22 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
         if (sch.queue[0].seed != 0) {
             set_seed(st.session, sch.queue[0].seed)
         }
-        if (st.media_grid.x > 0) {
-            sch.mrope_streams ++
+        var lost = false
+        for (sp in st.spans) {
+            st.n_media += sp.n
+            lost ||= !sp.done && empty(sp.rows)
+            if (sp.grid.x > 0) {
+                sch.mrope_streams ++
+            }
         }
         let wait_ms = sch.queue[0].t_submit != 0l ? int64(get_time_usec(sch.queue[0].t_submit)) / 1000l : 0l
-        let grid_note = st.media_grid.x > 0 ? " (mrope grid {st.media_grid.x}x{st.media_grid.y})" : ""
-        let media_note = st.n_media > 0l ? " + {st.n_media} media rows{grid_note}" : ""
-        to_log(LOG_INFO, "[stream {st.id}] start: prompt={length(st.prompt)} tok{media_note} (cached={st.n_cached}), queue_wait={wait_ms}ms, active={length(sch.streams) + 1}/{sch.max_streams}\n")
+        let media_note = st.n_media > 0l ? " ({st.n_media} media rows in {length(st.spans)} span(s))" : ""
+        to_log(LOG_INFO, "[stream {st.id}] start: prompt={length(st.prompt)} pos{media_note} (cached={st.n_cached}), queue_wait={wait_ms}ms, active={length(sch.streams) + 1}/{sch.max_streams}\n")
+        if (lost) {   // the request counted on the cache for a span the cache no longer holds: the caller encodes it and asks again
+            finish_stream(st, "media_lost", events)
+        }
         for (tk in st.prompt) {   // poll-surface preview: whole pieces up to the head cap
+            continue if (is_media_position(tk))
             let p = piece(m, tk)
             break if (length(st.prompt_head) + length(p) > 160)
             st.prompt_head += p
@@ -584,23 +655,25 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
             continue
         }
         let np = long_length(sch.streams[i].prompt)
-        // a media splice takes the whole quantum: the rows eval as ONE body, because the mask
-        // (gemma vision's non-causal span) is per-call and a chunk boundary would split it.
-        // Head tokens chunk normally up to media_at, the tail resumes after.
-        let media_pending = sch.streams[i].n_media > 0l && !sch.streams[i].media_done
-        if (media_pending && sch.streams[i].n_prefilled >= sch.streams[i].media_at) {
-            if (sch.streams[i].media_grid.x > 0) {   // qwen mrope: grid angles + the session-tracked position delta
-                eval_embd_span_mrope(m, sch.streams[i].session, sch.streams[i].media_embd,
-                                     sch.streams[i].n_media, 0l, sch.streams[i].n_media,
-                                     sch.streams[i].media_grid)
+        // a media span takes the whole quantum: its rows eval as ONE body, because the mask (gemma vision's
+        // non-causal span) is per-call and a chunk boundary would split it. Text chunks normally up to the next span.
+        let si = next_span(sch.streams[i].spans)
+        if (si >= 0 && prefill_media_body(m, sch, sch.streams[i], si)) {
+            pass
+        } elif (si >= 0 && sch.streams[i].n_prefilled >= sch.streams[i].spans[si].at) {
+            let sn = sch.streams[i].spans[si].n
+            if (sch.streams[i].spans[si].grid.x > 0) {   // qwen mrope: grid angles + the session-tracked position delta
+                eval_embd_span_mrope(m, sch.streams[i].session, sch.streams[i].spans[si].rows, sn, 0l, sn,
+                                     sch.streams[i].spans[si].grid)
             } else {
-                eval_embd(m, sch.streams[i].session, sch.streams[i].media_embd, sch.streams[i].n_media,
-                          sch.streams[i].media_non_causal)
+                eval_embd(m, sch.streams[i].session, sch.streams[i].spans[si].rows, sn, sch.streams[i].spans[si].non_causal)
             }
-            sch.streams[i].media_done = true
-            sch.prefill_tokens += sch.streams[i].n_media
+            sch.streams[i].spans[si].done = true
+            sch.streams[i].n_prefilled += sn
+            sch.prefill_tokens += sn
+            sch.prefill_evals ++
         } else {
-            let head_end = media_pending ? sch.streams[i].media_at : np
+            let head_end = si >= 0 ? sch.streams[i].spans[si].at : np
             let chunk = prefill_chunk(m, sch, head_end)
             let to_ckpt = sch.streams[i].ckpt_at - sch.streams[i].n_prefilled
             //! a checkpoint within a chunk and a half ends this chunk: stopping a chunk short of it would add a window, and a window's cost is mostly fixed
@@ -612,14 +685,15 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
             eval(m, sch.streams[i].session, sch.chunk)
             sch.streams[i].n_prefilled += take
             sch.prefill_tokens += take
+            sch.prefill_evals ++
             if (sch.streams[i].n_prefilled == sch.streams[i].ckpt_at) {
                 prefix_insert(sch.prefix, sch.pool, sch.streams[i].session, sch.streams[i].prompt)
                 to_log(LOG_INFO, "[stream {sch.streams[i].id}] prefix checkpoint at {sch.streams[i].ckpt_at} tok: the next prompt on this opening attaches here\n")
             }
         }
-        if (sch.streams[i].n_prefilled >= np && (sch.streams[i].n_media == 0l || sch.streams[i].media_done)) {
+        if (sch.streams[i].n_prefilled >= np) {
             let pf_ms = int64(get_time_usec(sch.streams[i].t_admit)) / 1000l
-            let pf_tok = np + sch.streams[i].n_media - sch.streams[i].n_cached
+            let pf_tok = np - sch.streams[i].n_cached
             let pf_rate = pf_ms > 0l ? 1000.0 * float(pf_tok) / float(pf_ms) : 0.0
             to_log(LOG_INFO, "[stream {sch.streams[i].id}] prefill done: {pf_tok} tok in {pf_ms}ms ({pf_rate} tok/s)\n")
             sch.streams[i].state = StreamState.decoding   // before sampling: sample_advance may finish it
@@ -641,7 +715,7 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
             }
             sch.recent_done |> push(DoneStream(
                 id = sch.streams[i].id, finish = sch.streams[i].finish,
-                n_prompt = long_length(sch.streams[i].prompt) + sch.streams[i].n_media,
+                n_prompt = long_length(sch.streams[i].prompt),
                 n_cached = sch.streams[i].n_cached,
                 n_gen = sch.streams[i].n_gen, ttft_us = sch.streams[i].ttft_us,
                 prompt_head = sch.streams[i].prompt_head, gen_tail = string(sch.streams[i].gen_tail_bytes),
@@ -649,7 +723,7 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
             if (sch.streams[i].session.device_kv) {
                 park_stream(m, sch, sch.streams[i])
             } elif (sch.paged) {
-                if (sch.streams[i].n_media == 0l) {   // media KV does not follow from the token ids
+                if (sch.streams[i].finish != "media_lost") {
                     donate_stream(m, sch, sch.streams[i])
                 }
                 release_kv_pages(sch.streams[i].session)
@@ -664,6 +738,66 @@ def scheduler_step(m : Model; var sch : Scheduler; var events : array<SchedEvent
     return !empty(sch.streams) || !empty(sch.queue)
 }
 
+//! One eval for span `si` and the text around it, up to a chunk of text: a prefill call's cost is mostly fixed, so
+//! the text either side of a span rides the span's call. False where the body is not one eval - a recurrent
+//! checkpoint ends a chunk, the span stands bare.
+def private prefill_media_body(m : Model; var sch : Scheduler; var st : Stream; si : int) : bool {
+    let lo = st.n_prefilled
+    let at = st.spans[si].at
+    let sn = st.spans[si].n
+    let head = at - lo
+    let room = prefill_chunk(m, sch, at)
+    return false if (head > room)
+    let stop = si + 1 < length(st.spans) ? st.spans[si + 1].at : long_length(st.prompt)
+    let hi = min(stop, at + sn + room - head)
+    return false if (hi - lo == sn || (st.ckpt_at > lo && st.ckpt_at <= hi))
+    sch.chunk |> resize(head)
+    for (k in range64(head)) {
+        sch.chunk[k] = st.prompt[lo + k]
+    }
+    let ntail = hi - at - sn
+    sch.chunk_tail |> resize(ntail)
+    for (k in range64(ntail)) {
+        sch.chunk_tail[k] = st.prompt[at + sn + k]
+    }
+    media_body_rows(m, st.session, sch.chunk, st.spans[si].rows, sn, long_length(st.spans[si].rows) / sn, sch.chunk_tail, sch.body)
+    let masked = st.spans[si].non_causal || st.spans[si].grid.x > 0
+    eval_embd_body(m, st.session, sch.body, hi - lo, masked ? head : 0l, masked ? head + sn : 0l, st.spans[si].grid)
+    st.spans[si].done = true
+    st.n_prefilled = hi
+    sch.prefill_tokens += hi - lo
+    sch.prefill_evals ++
+    return true
+}
+
+//! the first span whose K/V does not stand yet; -1 when every span's does
+def private next_span(spans : array<MediaSpan>) : int {
+    for (sp, i in spans, count()) {
+        return i if (!sp.done)
+    }
+    return -1
+}
+
+//! whether a prefix hit of `matched` positions ends inside a span
+def private cuts_a_span(spans : array<MediaSpan>; matched : int64) : bool {
+    for (sp in spans) {
+        return true if (matched > sp.at && matched < sp.at + sp.n)
+    }
+    return false
+}
+
+//! The spans a prefix hit of `matched` positions covers stand as attached: their rows are never evaled, and a grid
+//! span's rope advance is restored on the session, which ropes the positions after it by that delta.
+def private adopt_spans(var st : Stream; matched : int64) {
+    for (sp in st.spans) {
+        continue if (sp.at + sp.n > matched)
+        sp.done = true
+        if (sp.grid.x > 0) {
+            st.session.rope_pos_delta += int64(max(sp.grid.x, sp.grid.y)) - sp.n
+        }
+    }
+}
+
 // Donate a finished stream's KV pages, first evaling what the cache still lacks. A "length"
 // finish leaves the last emitted token pending (sampled, never fed back); a "stop" finish already
 // evaled every emitted token — the stop was sampled from the last one's eval — so only the close
diff --git a/modules/dasLLAMA/dasllama/dasllama_vulkan_tower.das b/modules/dasLLAMA/dasllama/dasllama_vulkan_tower.das
index 36d480a881..94c0231ad4 100644
--- a/modules/dasLLAMA/dasllama/dasllama_vulkan_tower.das
+++ b/modules/dasLLAMA/dasllama/dasllama_vulkan_tower.das
@@ -1160,7 +1160,7 @@ def private vulkan_gemma4a_blocks(t : Gemma4aEncoder; var s : Gemma4aState; npos
     let rel_cap_rows = past + 1l
     let tail_dim = t.proj_dim
     if (d % 64l != 0l || ff % 64l != 0l || ff < 2l * d || t.n_head * hs != d || (hs != 64l && hs != 128l) || past != int64(G4A_ATTN_PAST) || gemma4a_softcap() != G4A_ATTN_CAP
-            || npos > VT_MAX_ENCODE_ROWS || npos <= 0l || tail_dim % 64l != 0l || tail_dim > max(d, ff)) {
+            || npos > VT_MAX_ENCODE_ROWS || npos <= 0l || tail_dim % 64l != 0l || tail_dim > max(d, ff) || tail_dim != gemma4a_mid_dim(t)) {
         return vt_decline(r, VulkanTowerDecline.shape)
     }
     let arm = vt_arm(r)
@@ -3752,7 +3752,7 @@ def dasllama_vulkan_tower_register {
         register_gemma4a_gpu(@@vulkan_gemma4a_blocks, @@vulkan_tower_serves_exact)
         register_canary_gpu(@@vulkan_canary_blocks, @@vulkan_tower_serves_exact)
         register_qwen3a_front_gpu(@@vulkan_q3a_front)
-        register_qwen3a_mel_gpu(@@vulkan_q3a_mel)
+        register_whisper_mel_gpu(@@vulkan_q3a_mel)
         register_gemma4a_chunk_gpu(@@vulkan_gemma4a_chunk)
         register_canary_front_gpu(@@vulkan_canary_front)
     }
diff --git a/modules/dasLLAMA/dasllama/dasllama_whisper.das b/modules/dasLLAMA/dasllama/dasllama_whisper.das
index a10c46308c..80a333e5e7 100644
--- a/modules/dasLLAMA/dasllama/dasllama_whisper.das
+++ b/modules/dasLLAMA/dasllama/dasllama_whisper.das
@@ -392,7 +392,7 @@ def private wm_mm_rq(w : WhisperModel; var y : array<float>; woff : int64; x : a
 
 // ===== ggml bin container parsing =====
 
-// One tensor's location in the bin: ggml ttype (0=f32, 1=f16), element count, absolute
+// One tensor's location in the bin: ggml ttype (0=f32, 1=f16, 8=q8_0), element count, absolute
 // byte offset of the raw data (which follows the name with NO alignment padding).
 struct private WTensorRec {
     ttype : int
@@ -411,7 +411,9 @@ def private bytes_str(b : array<uint8> | #; o, n : int64) : string {
     return s
 }
 
-// Read a tensor's raw data (f32 or f16) into dst[dst_off..) as fp32. Byte-wise reads — the
+let private GGML_FTYPE_MOSTLY_Q8_0 = 7   //!< the file type whisper.cpp's quantizer stamps a q8_0 bin with
+
+// Read a tensor's raw data (f32, f16 or Q8_0 blocks) into dst[dst_off..) as fp32. Byte-wise reads — the
 // bin stores tensor data unaligned.
 def private wt_read(recs : table<string; WTensorRec>; b : array<uint8> | #; name : string;
                     var dst : array<float>; dst_off, n : int64) {
@@ -422,15 +424,7 @@ def private wt_read(recs : table<string; WTensorRec>; b : array<uint8> | #; name
     if (r.n_elem != n) {
         panic("dasLLAMA whisper: tensor '{name}' has {r.n_elem} elements, want {n}")
     }
-    if (r.ttype == GGML_TYPE_F32) {
-        for (i in range64(n)) {
-            dst[dst_off + i] = rd_f32(b, r.off + i * 4l)
-        }
-    } else {
-        for (i in range64(n)) {
-            dst[dst_off + i] = f16_to_f32(rd_u16(b, r.off + i * 2l))
-        }
-    }
+    ggml_bin_read_f32(b, r.ttype, r.off, n, dst, dst_off)
 }
 
 // Conv1d weight (flat [c_out][c_in][k=3], k contiguous — torch layout) permuted to the
@@ -802,8 +796,8 @@ def private whisper_index(bytes : array<uint8> | #; n_bytes : int64; var st : Wh
     st.e.n_text_layer = int64(rd_i32(bytes, o)); o += 4l
     let n_mels = int64(rd_i32(bytes, o)); o += 4l
     let ftype = rd_i32(bytes, o) % 1000; o += 4l
-    if (ftype != GGML_TYPE_F32 && ftype != GGML_TYPE_F16) {
-        panic("dasLLAMA whisper: unsupported ftype {ftype} (only f32/f16 bins)")
+    if (ftype != GGML_TYPE_F32 && ftype != GGML_TYPE_F16 && ftype != GGML_FTYPE_MOSTLY_Q8_0) {
+        panic("dasLLAMA whisper: unsupported ftype {ftype} (f32, f16 and q8_0 bins load)")
     }
 
     // mel filterbank
@@ -866,8 +860,8 @@ def private whisper_index(bytes : array<uint8> | #; n_bytes : int64; var st : Wh
         let nl = int64(rd_i32(bytes, o + 4l))
         let tt = rd_i32(bytes, o + 8l)
         o += 12l
-        if (tt != GGML_TYPE_F32 && tt != GGML_TYPE_F16) {
-            panic("dasLLAMA whisper: unsupported tensor type {tt} (only f32/f16 bins)")
+        if (tt != GGML_TYPE_F32 && tt != GGML_TYPE_F16 && tt != GGML_TYPE_Q8_0) {
+            panic("dasLLAMA whisper: unsupported tensor type {tt} (f32, f16 and q8_0 tensors load)")
         }
         var ne = 1l
         for (_i in range(nd)) {
@@ -877,7 +871,7 @@ def private whisper_index(bytes : array<uint8> | #; n_bytes : int64; var st : Wh
         let name = bytes_str(bytes, o, nl)
         o += nl
         recs[name] = WTensorRec(ttype = tt, n_elem = ne, off = o)
-        o += ne * (tt == GGML_TYPE_F32 ? 4l : 2l)
+        o += ggml_bin_tensor_bytes(tt, ne)
     }
 
     // encoder tower layout -> AudioTower scalars + one job per tensor, in blob-offset order
diff --git a/modules/dasLLAMA/followup_general.md b/modules/dasLLAMA/followup_general.md
index ac60e6f4c5..4262a269e8 100644
--- a/modules/dasLLAMA/followup_general.md
+++ b/modules/dasLLAMA/followup_general.md
@@ -2103,3 +2103,14 @@
    the reference up with the channel's pending count in one step and their owner joins. Several
    workers share one events channel, so the count does not fit them as it stands. Done = a worker
    exit the owner can wait on - a status a worker, or the count sized to the workers.
+
+212. **A request served off the prefix cache can answer differently from its cold run.** A cached run attaches
+    every row of the prompt but its last token's and evals that token alone, where the cold run evaled it
+    inside the prefill batch. On SmolLM2-135M Q8_0 on the CPU, a 138-token prompt (the model's default system
+    line and the robot story of `utils/dasllama-server/test_openai_server_stream.das`) reads "eyes sparkle"
+    cold and "eyes light up" off the cache under greedy sampling, the two parting at the fifth generated
+    token; a 117-token prompt reads the same both ways, and two cached runs always agree. The classic
+    attention mode set in the server's thread did not close it, which a rounding difference alone would
+    predict it to. The work: the cached K/V rows against a cold prefill's row by row at that prompt, to name
+    the row that differs and whether it is the last token's alone; then either the cold run's last row
+    evaled as the cached run evals it, or the difference stated in the server's README.
diff --git a/modules/dasLLAMA/followup_metal.md b/modules/dasLLAMA/followup_metal.md
index 9824de02df..2b3d4faa4c 100644
--- a/modules/dasLLAMA/followup_metal.md
+++ b/modules/dasLLAMA/followup_metal.md
@@ -809,15 +809,6 @@ that scales with the model and not with the drafts - the verify's two rows again
 weight pass at its bandwidth roof should be nearly free. The work: the round's stage split on
 the 9B (`harness/mtp_ruler.das`, the verify against the plain step) to name the term.
 
-## 28. The Metal tower's qwen3a mel hook raises no counter
-
-`metal_q3a_mel` (`dasllama/dasllama_metal_tower.das`, registered through
-`register_qwen3a_mel_gpu`) serves the qwen3a log-mel front on the device and raises none of
-`metal_tower_stats()`'s counters - `encodes`, `blocks` and `convs` all stay flat across a served
-mel - so no gate can cover the hook under `REVIEW_TOWER.md`'s covering rule, which needs a
-counter that rises on a leg where the hook is the only hook raising it. The Vulkan tower counts
-the same hook under `vulkan_tower_stats()`'s `mels`. The work: a `mels` counter in
-`metal_tower_stats()` that the mel hook raises, and the qwen3a Metal cell asserting it rises.
 ## 29. The Metal tower's K-panel pool release has no cell
 
 The Metal tower's block encodes (`dasllama/dasllama_metal_tower.das`) acquire the K panel from
@@ -878,14 +869,6 @@ Llama-3.2-3B, M5 Max), and leaves the decode driver to upload them again. Three
   releases the slice and takes a larger one). The work: the old slice's rows copied device-side
   into the new one.
 
-## 37. A served Qwen3-ASR transcription runs its decoder on the CPU
-
-The server's ASR worker context carries no Metal mode, so a family whose decoder is an LLM
-(Qwen3-ASR) prefills and decodes it on the CPU arm while the reference server runs the same file
-offloaded. The row is `harness/served_bench.das --asr-url <server> --clip <wav>` on both servers.
-The work: the worker serving the decoder on the device where one is armed, and that row beside
-the reference's.
-
 ## 38. Two ASR models transcribing at once slow each other
 
 Two ASR models asked for the same clip at the same instant each take several times their idle
@@ -894,3 +877,96 @@ idle wall. The rows are `harness/served_bench.das --scene --scene-asr <id> --sce
 (each lane's median alone beside its median in the scene). The work: a kernel profile of the
 scene that says where the two transcriptions meet, and the dispatch the speech workers take set
 from it.
+
+## 39. Audio stages a Metal chain leaves on the CPU
+
+A Metal chain serves every stage of its family on the device (`REVIEW_TOWER.md`); these do not.
+Each is a stage and the models it holds for, read off the drivers' own gates:
+
+- **The whisper mel** runs on the CPU on every whisper size.
+- **The whisper decode step** serves on the device from a text width of 512 up
+  (`METAL_WDEC_STEP_MIN_D`); tiny's (384) runs on the CPU, where the device step is the slower
+  one - 21.8 ms a request's decode against 17.8.
+- **The parakeet decode** (the TDT predictor and joint, the pick) and **its mel** run on the CPU: of a
+  64 s clip's 78 ms, the decode is 27.0 (260 steps at 78 us) and the mel 7.1, beside 44.9 of encode
+  on the device.
+- **The q8 encoder lane** declines `quant_mode` on gemma4a, canary and parakeet, so those families
+  serve their f32 lane on the device at the larger image; the whisper-class tower reads q8.
+- **The canary perception projection** (`cn.proj`, 7 ms of a 64 s clip) runs on the CPU, and so do
+  the preemphasis and windowing ahead of the device front. A clip whose first conv output passes
+  1 GB (about five minutes) keeps the CPU front, and the q8 encoder lane the whole CPU chain.
+- **The Qwen3-ASR projector** (`q3a.proj`, 1.6 ms a chunk) runs on the CPU, and its mel's windowing
+  and clamp around the device spectrum.
+- **The whisper-class chat towers' mel** (`log_mel_chunks`; Qwen2-Audio, Qwen2.5-Omni, Ultravox,
+  Voxtral) takes its spectrum from the device mel seat; the reflect pad, the windowing, the global
+  clamp and the chunk split run on the CPU around it. A mel count off the seat's 64 lattice keeps
+  the CPU spectrum.
+- **The whisper-class projector tail** runs on the CPU on a q8 tower - its projector planes are not
+  on the device - and on a tower whose tail widths are off the f32 GEMM lattice.
+- **The vision towers' im2col** (gemma3v, gemma4v) runs on the CPU, and so does gemma4v's sum of its
+  two position-table rows a patch; the patch conv and the tail run on the device. The tail falls
+  back to the CPU where the patch grid does not pool whole or its widths are off the GEMM lattice.
+  The q8 lane's whole chain runs on the CPU. qwen3v and qwen25v have had no stage-by-stage check of
+  their merger tails.
+- **Qwen3-Omni** has had no stage-by-stage check.
+
+The work: each stage on the device, and a counter per stage a gate can read, so a served model's
+row names the stages it ran and where.
+
+## 40. The served-media arc's sibling sets stand unfolded
+
+Each pair below differs on the one axis named, and the fold is behavior-neutral unless it says otherwise.
+
+- **Tail scratch.** `tw_tail_make` / `_land`, `g4a_tail_make` / `_land`, `g4v_ends_make` / `_land`, `g3v_tail_make` /
+  `_land` and `metal_canary_front`'s `g_tw_cn_bufs` each carry their own `bytes_*` fields and release list for
+  pool buffers that `TwBufSet` / `tw_take` / `tw_release` hold (`dasllama/dasllama_metal_tower.das`). The fold: a
+  `scratch : TwBufSet` a tail struct, one `tw_release` in its land. Proof: the audio and vision areas.
+- **The prefix probe.** `prefix_match_len_` repeats `prefix_attach_`'s whole-page walk and partial-page pick with
+  no side effect (`dasllama/dasllama_prefix.das`). The fold: one read-only walk that attach applies its effects
+  over, so the probe equals the attach by construction. Proof: `test_kv_prefix.das`, `test_scheduler.das`.
+- **The pool kernels.** `MetalTwPool2` (a row pair) and `MetalTwPool2d` (a k x k block) differ on the window
+  (`dasllama/dasllama_metal_prefill.das`); one kernel takes a window of its own width and height.
+- **The gated rows.** `MetalTwSwigluRows` and `MetalG4aGlu` walk a row's two halves alike and differ on the gate
+  (`silu(b) * a` against `a * sigmoid(b)`) and on their argument shape; a class template with the gate abstract
+  stamps both. `MetalG4aGlu` sits in gemma4a's block loop: the stamp's generated source is diffed against it.
+- **The subsample front.** `metal_canary_front` and `metal_parakeet_encode` run the same ten dispatches in the
+  same order and differ on the taps buffer, the valid-row clamps and the GEMM form; one body takes the three.
+  Proof: the parakeet and canary `mtower` arms of `test_model_image.das`.
+- **The spectrum's tile.** `metal_canary_front` runs its DFT GEMM on the half-staged f32 tile and `metal_q3a_mel`
+  on the exact f32 tile, where a quiet bin sits 80 dB under the loud ones. Folding the two picks one tile: the
+  exact one, with canary's rel-l2 read again.
+- **The inline media turn.** `render_prompt_media` (with `text_before`) and `render_user_spans` render the same
+  turn as a head and tail pair and as one position stream (`dasllama/dasllama_chat.das`); the first becomes the
+  second with one mark, split at the id run. The single-chat media turn then takes the text renderer's arms
+  (displaced tool results, the open-turn close): `test_vision_chat.das`'s render cells are the check.
+- **The per-layer input's gate.** `ple_pre_prefill_pad_gated` and `ple_pre_prefill_gated` differ on the id source
+  (`dasllama/dasllama_common.das`); one gate reads an empty token range as the padding token and keeps the CPU's
+  one-gather pad arm.
+- **Smaller pairs.** `conv2_mm` beside `wt_mm` (where the q8 region's offset lives); `audio_tower_half_gemms`
+  beside `stage_qwen3a_tower`'s inline predicate (whether Q8_0 is admitted); `kv_blob_grow` beside
+  `reserve_resize` (no fill against zero fill); the three audio probes' file open beside `gguf_file_arch`'s;
+  `uncovered_media` and `media_spans`' scan for a ref's id run, and `collect_media_refs` beside `message_parts`
+  (`utils/dasllama-server/openai_server.das`); the device tail's landing in `dasllama_gemma3v.das` and
+  `dasllama_gemma4v.das`; the bench's `unseen_clip` temp path beside `create_temp_file`; the test helpers
+  `with_tower_audio_server` / `with_audio_server`, `tail_gpu_cell` / `test_gemma3v_tail_gpu`'s body, and the
+  two heap-flat legs.
+- **Not a fold.** gemma4v's position rows add as `x + (ex + ey)` on the device and `(x + ex) + ey` on the CPU; one
+  helper changes one side's sums. The CPU mel's power spectrum is shared by `log_mel_spectrum_cpu` and
+  `dasllama_qwen3a.das`, the mel sums behind it are not: each matches its own reference.
+
+## 41. The projector tails run on the f32 tiles beside a resident halfword copy
+
+The whisper-class, gemma-3 and gemma-4 vision tails (`tw_tail_body`, `g3v_tail_body`, `g4v_tail_body`) take their
+projection GEMMs through `enc_f32_mm` in the command buffer where the halfword copy of the same weight blob
+serves the block GEMMs. Neither form has been raced on a tail. The work: one in-process race a tail on the half
+tile against the f32 tile (an encode's wall, the rows' distance from the CPU tail), and the tail on whichever
+holds its bar and reads faster.
+
+## 42. The ASR decoder drivers keep a dropped state's id for the process's life
+
+`g_wd_dropped` holds the id of every decoder state whose waiting cross-KV planes were dropped unread, and a
+state leaves it only at its next window (`dasllama/dasllama_metal_asr_dec.das`; the Vulkan driver carries the
+same record in `dasllama_vulkan_asr_dec.das`). A transcription makes a fresh state, so a state whose last
+window was dropped never returns: eight bytes a transcription, for as long as the server runs. The work: the
+pending mark on the state itself (a flag beside `DecoderState.gpu_uid`, the driver's one pending id beside
+it), so nothing outlives the state; both drivers in one change, the Vulkan one on a Vulkan box.
diff --git a/modules/dasLLAMA/followup_vulkan.md b/modules/dasLLAMA/followup_vulkan.md
index c7b56b613d..61411a1ba3 100644
--- a/modules/dasLLAMA/followup_vulkan.md
+++ b/modules/dasLLAMA/followup_vulkan.md
@@ -2151,3 +2151,10 @@ module) is independent and can land any time - it is pure structure.
     changes the k4 bytes behind the `khrx` and `mmqx` races and every recorded probe reading in
     `PERF_LEDGER.md`. The fold is admissible only together with a re-reading of those rows, in a session
     that re-stamps them.
+
+144. **The gemma4a chain declines a widening audio embedder.** The Vulkan chain's projector tail sizes
+   one tail width for the out projection, the norm and the embedder (`tail_dim`), which holds where
+   the embedder is square (E2B). On E4B the embedder widens the encoder's 1536 to the decoder's 2560
+   (`gemma4a_mid_dim` against `proj_dim`), and the chain declines `shape`, so the CPU chain serves
+   E4B audio. Done = the tail's regions, tiles and buffers at the two widths (the Metal chain's
+   `g4a_tail_body` is the form), and `test_gemma4a_vulkan_twin` run on the E4B pair.
diff --git a/modules/dasLLAMA/harness/served_bench.das b/modules/dasLLAMA/harness/served_bench.das
index 80e60e6573..2893847ff4 100644
--- a/modules/dasLLAMA/harness/served_bench.das
+++ b/modules/dasLLAMA/harness/served_bench.das
@@ -9,7 +9,7 @@ options indenting = 4
 //       [--model <id>] [--sizes 3000,9000] [--reply 200] [--reps 3] [--settle 0] [--corpus <file>] [--think] [--follow-up]
 //       [--asr-url <base> --clip a.wav --clip b.wav [--asr-model <id>] [--under-load [--load-tokens 1500]]] [--no-chat]
 //       [--tts-url <base> [--tts-model <id> ...] [--tts-voice <name>] [--tts-text <text>]]
-//       [--scene [--scene-asr <id> ...] [--scene-flood]] [--image a.jpg ...]
+//       [--scene [--scene-asr <id> ...] [--scene-flood]] [--image a.jpg ...] [--chat-clip a.wav ...]
 //
 // Per prompt size, `--reps` pairs of streamed chat turns under one system prompt of about that many
 // tokens, greedy, thinking off unless --think:
@@ -37,9 +37,10 @@ options indenting = 4
 // the finished WAV, so the wall is the time to first audio - over `--reps` reps behind one untimed request,
 // beside the seconds of speech it carried and the real-time factor the two imply.
 //
-// Image rows (`--image`, one row each, at `--url`): a question about the image answered in ONE token, so the wall is
-// the image's encode, the prompt's prefill and that token - per rep under a system line no server has seen, then a
-// second question under the same line (a server that keeps the image's rows answers that one from its cache).
+// Media rows (`--image` and `--chat-clip`, one row a file, at `--url`): a question about the image or the clip, the
+// part ahead of the text, answered in ONE token, so the wall is the part's encode, the prompt's prefill and that token
+// - per rep under a system line no server has seen, then a second question under the same line (asked again: a server
+// that pays for a part once neither encodes nor prefills it a second time).
 //
 // The scene (`--scene`): a chat turn of `--load-tokens` tokens decodes at `--url` while every `--scene-asr`
 // model transcribes the first `--clip` and the first `--tts-model` speaks, each lane on a thread of its own from
@@ -141,6 +142,10 @@ struct Args {
     @clarg_doc = "An image to ask the chat server about (repeatable, jpg or png), one row each"
     image : array<string>
 
+    @clarg_name = "chat-clip"
+    @clarg_doc = "An audio clip to ask the chat server about as an input_audio part (repeatable, wav), one row each"
+    chat_clip : array<string>
+
     @clarg_short = "?"
     @clarg_name = "show-help"
     @clarg_doc = "Show this help and exit"
@@ -198,6 +203,7 @@ struct Seen {
     why : string
     wall_us : int64
     prompt_tokens : int64
+    text : string    //!< the reply, for a request that asked for more than its one timed token
 }
 
 //! one synthesis request as the client saw it; `why` is non-empty when it cannot enter a row
@@ -483,12 +489,37 @@ def private chat_rows(plan : Plan; corpus, sizes : string; settle : int; fixed_c
     return tally
 }
 
-//! one whole transcription request under the client clock, the clip uploaded as a multipart form
+//! A copy of `clip` no server has heard - one sample, picked off the clock, moved - as a 16-bit temp file;
+//! "" when `clip` is no PCM WAV or the copy cannot be written.
+def unseen_clip(clip : string) : string {
+    var samples : array<float>
+    var rate = 0
+    var channels = 0
+    var path = ""
+    if (read_wav(clip, samples, rate, channels) && !empty(samples)) {
+        let ticks = ref_time_ticks()
+        let at = ticks % long_length(samples)
+        samples[at] += samples[at] < 0.5 ? 2.0 / 32767.0 : -2.0 / 32767.0   // two steps: write_wav truncates, and one would round back
+        var err = ""
+        path = path_join(temp_directory(err), "served_bench_{ticks}.wav")
+        if (!write_wav(path, samples, uint(rate), channels)) {
+            path = ""
+        }
+    }
+    delete samples
+    return path
+}
+
+//! one whole transcription request under the client clock, an unseen copy of the clip uploaded as a multipart form
 def transcribe(speech : Speech; clip : string) : Heard {
     var heard = Heard()
+    let unseen = unseen_clip(clip)
     let t0 = ref_time_ticks()
-    let res = openai_audio::transcribe(client_of(speech.url), speech.model, clip)
+    let res = openai_audio::transcribe(client_of(speech.url), speech.model, empty(unseen) ? clip : unseen)
     heard.wall_us = int64(get_time_usec(t0))
+    if (!empty(unseen)) {
+        remove(unseen)
+    }
     if (!res.ok) {
         heard.why = "HTTP {res.error.status}"
         return heard
@@ -589,13 +620,20 @@ def private speech_rows(speech : Speech; clips : array<string>; reps : int; unde
     return tally
 }
 
-//! one question about an image, answered in one token: the wall is the image's encode, the prompt's prefill and that token
-def see(plan : Plan; system, question, uri : string) : Seen {
+let EYEBALL_TOKENS = 96   //!< the untimed request's reply budget: enough to read whether the model saw the part
+
+//! One question about a media part - an image's data URI, or the base64 of an audio file under `is_audio` - answered
+//! in one token: the wall is the part's encode, the prompt's prefill and that token. The part leads the message, so
+//! another question about it shares the prompt up to the part's end.
+def see(plan : Plan; system, question, payload : string; is_audio : bool = false; max_tokens : int = 1) : Seen {
     var seen = Seen()
     let t0 = ref_time_ticks()
-    var res <- chat_vision(client_of(plan.url), plan.model, question, uri, 1, system)
+    let eyeball = max_tokens > 1   //! the request whose reply is read asks a thinking model for the answer, not its thought
+    var res <- (is_audio ? chat_audio(client_of(plan.url), plan.model, question, payload, max_tokens, system, true, eyeball)
+        : chat_vision(client_of(plan.url), plan.model, question, payload, max_tokens, system, true, eyeball))
     seen.wall_us = int64(get_time_usec(t0))
     seen.prompt_tokens = int64(res.response.usage.prompt_tokens)
+    seen.text = empty(res.response.choices) ? "" : res.response.choices[0].message.content
     if (!res.ok) {
         seen.why = "HTTP {res.error.status}"
     } elif (seen.prompt_tokens == 0l) {
@@ -607,22 +645,35 @@ def see(plan : Plan; system, question, uri : string) : Seen {
 
 //! The image rows, one an image: per rep a question under a system line no server has seen, then another question
 //! under the same line - what the first token of each waits for, and the prompt tokens the image and the text make.
-def image_rows(plan : Plan; images : array<string>; run : string) : Tally {
+def image_rows(plan : Plan; images : array<string>; run : string) : Tally
+    => media_rows(plan, images, run, false)
+
+//! The media rows, one a file - an image, or an audio clip in a chat turn under `is_audio`: per rep a question about
+//! it under a system line no server has seen, then another question under the same line. A server that pays for a
+//! part once answers the second from its cache: the part is neither encoded nor prefilled again.
+def media_rows(plan : Plan; files : array<string>; run : string; is_audio : bool) : Tally {
     var tally = Tally()
-    for (path in images) {
+    let what = is_audio ? "chat clip" : "image"
+    let ask = is_audio ? "Transcribe this audio." : "What is in this picture?"
+    let ask_again = is_audio ? "What language is spoken in this audio?" : "What colors stand out in this picture?"
+    for (path in files) {
         let name = base_name(path)
-        let uri = image_file_data_uri(path)
-        let warmup = empty(uri) ? "the file is not there" : see(plan, "", "What is in this picture?", uri).why   //! the untimed request ahead of the row
-        if (!empty(warmup)) {
-            print("{plan.tag}  image {name}  REFUSED: {warmup}\n")
+        let payload = is_audio ? file_base64(path) : image_file_data_uri(path)
+        //! the untimed request ahead of the row asks for a whole answer: the reply is printed, so a row is read with what the model said
+        let first = empty(payload) ? Seen(why = "the file is not there") : see(plan, "", ask, payload, is_audio, EYEBALL_TOKENS)
+        if (!empty(first.why)) {
+            print("{plan.tag}  {what} {name}  REFUSED: {first.why}\n")
             tally.refused++
             continue
         }
+        print("{plan.tag}  {what} {name} says: {replace(first.text, "\n", " ")}\n")
         var prompt_tokens = 0l
+        //! a rep shares its system line's opening with the rep before it; this untimed request gives the first rep the same
+        see(plan, "Session {run}-{name}-lead. Answer briefly.", ask, payload, is_audio)
         var walls <- collect_reps(plan.reps) $(rep) {
             let system = "Session {run}-{name}-{rep}. Answer briefly."
-            let a = see(plan, system, "What is in this picture?", uri)
-            let b = empty(a.why) ? see(plan, system, "What colors stand out in this picture?", uri) : a
+            let a = see(plan, system, ask, payload, is_audio)
+            let b = empty(a.why) ? see(plan, system, ask_again, payload, is_audio) : a
             return RepWall(why = b.why) if (!empty(b.why))
             if (rep > 0 && a.prompt_tokens != prompt_tokens) {
                 return RepWall(why = "{a.prompt_tokens} prompt tokens, {prompt_tokens} the rep before")
@@ -633,10 +684,10 @@ def image_rows(plan : Plan; images : array<string>; run : string) : Tally {
         if (empty(walls.why)) {
             let first_s = spread_of(walls.first)
             let again_s = spread_of(walls.again)
-            print("{plan.tag}  image {name}: {prompt_tokens} prompt tokens, first token {first_s.median:.1f} ms (cv {first_s.cv:.1f}%), asked again {again_s.median:.1f} ms (cv {again_s.cv:.1f}%){flag(first_s.cv)}\n")
+            print("{plan.tag}  {what} {name}: {prompt_tokens} prompt tokens, first token {first_s.median:.1f} ms (cv {first_s.cv:.1f}%), asked again {again_s.median:.1f} ms (cv {again_s.cv:.1f}%){flag(first_s.cv)}\n")
             tally.rows++
         } else {
-            print("{plan.tag}  image {name}  REFUSED {walls.why}\n")
+            print("{plan.tag}  {what} {name}  REFUSED {walls.why}\n")
             tally.refused++
         }
         delete walls
@@ -934,8 +985,8 @@ def args_error(cfg : Args; reps : int) : string {
     if (cfg.under_load && (empty(cfg.url) || !speech_on)) {
         return "--under-load times --clip rows at --asr-url beside a chat turn at --url - it needs all three"
     }
-    if (!empty(cfg.image) && empty(cfg.url)) {
-        return "--image asks the chat server at --url about each image - it needs --url"
+    if ((!empty(cfg.image) || !empty(cfg.chat_clip)) && empty(cfg.url)) {
+        return "--image and --chat-clip ask the chat server at --url about each file - they need --url"
     }
     if (cfg.follow_up && (empty(cfg.url) || cfg.no_chat)) {
         return "--follow-up is one of the chat rows at --url - it needs --url, and not --no-chat"
@@ -1000,8 +1051,13 @@ def main : int {
         tally.rows += looked.rows
         tally.refused += looked.refused
     }
-    if (!chat_on && !speech_on && !tts_on && !cfg.scene && empty(cfg.image)) {
-        print("error: nothing to time - give --url for the chat rows (and --image for the image rows), --asr-url with --clip for the transcription rows, --tts-url for the synthesis rows, --scene for all of them at once\n")
+    if (!empty(cfg.url) && !empty(cfg.chat_clip)) {
+        let heard = media_rows(Plan(url = cfg.url, tag = tag, model = cfg.model, reps = reps), cfg.chat_clip, "{ref_time_ticks()}", true)
+        tally.rows += heard.rows
+        tally.refused += heard.refused
+    }
+    if (!chat_on && !speech_on && !tts_on && !cfg.scene && empty(cfg.image) && empty(cfg.chat_clip)) {
+        print("error: nothing to time - give --url for the chat rows (and --image / --chat-clip for the media rows), --asr-url with --clip for the transcription rows, --tts-url for the synthesis rows, --scene for all of them at once\n")
     }
     return tally.rows == 0 || tally.refused > 0 ? 1 : 0
 }
diff --git a/modules/dasLLAMA/performance/records/m4.json b/modules/dasLLAMA/performance/records/m4.json
index 21d9492291..6d46f32288 100644
--- a/modules/dasLLAMA/performance/records/m4.json
+++ b/modules/dasLLAMA/performance/records/m4.json
@@ -1868,70 +1868,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/models/gemma-4-E4B-it-Q8_0.gguf --image-mmproj ~/models/mmproj-gemma-4-E4B-it-BF16.gguf --image ~/models/coco-val2017-000000039769.jpg -r 3 -t 10 -o json --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":116.96899999999999
-          },
-          "img:pp":{
-            "tok_s":686.95533469256543
-          },
-          "img:tg":{
-            "tok_s":45.489373255944535,
-            "text":"The user wants a one-sentence description of the provided image.\nThe image contains two cats lying on a pink surface.\n\nPlan: Describe the main subjects"
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E4B-it-Q8_0.gguf",
-            "sha256":"34be82b17b4942d389b9b527170c4b058027abdd32531fda063d3d97dd8ce80a",
-            "bytes":8031242688
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E4B-it-BF16.gguf",
-            "sha256":"f77995e4b6a569ab8f0d1bfdb7e8da4a0fa5b9e6f309b9bf3bdb76164d75e29f",
-            "bytes":991552256
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"llama.cpp",
         "backend":"metal",
@@ -3704,70 +3640,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/models/gemma-4-E2B-it-Q8_0.gguf --image-mmproj ~/models/mmproj-gemma-4-E2B-it-bf16.gguf --image ~/models/coco-val2017-000000039769.jpg -r 3 -t 10 -o json --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":116.57599999999999
-          },
-          "img:pp":{
-            "tok_s":1349.2708747772838
-          },
-          "img:tg":{
-            "tok_s":84.976688061908348,
-            "text":": This is an image of two tabby cats lying on a pink surface."
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"llama.cpp",
         "backend":"metal",
@@ -4060,101 +3932,6 @@
             "bytes":173131
           }
         ]
-      },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m gemma-4-E2B-it-Q8_0.gguf -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":556.13199999999995,
-            "audio_s":11,
-            "encode_ms":58.156999999999996,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":1523.7439999999999,
-            "audio_s":33,
-            "encode_ms":164.203,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:gb1.wav":{
-            "ms":10201.476000000001,
-            "audio_s":198.734375,
-            "encode_ms":916.78800000000001,
-            "text":"Fellow Americans, this day has brought terrible news and great sadness to our country. At 9:00 this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kulpna Shawla, and Elaine Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity in an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce atmosphere of the Earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens, who created space, he who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families and may God may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":13664.558000000001,
-            "audio_s":273.28724999999997,
-            "encode_ms":1272.1220000000001,
-            "text":"Henry F. Phillips from Wikipedia, the free encyclopedia at en.wikipedia.org. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips major contribution was in driving the crosshead concept forward to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, US patent number 2,46343, US patents 2,46837 to 2,46840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screwmakers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips screw company and the American Screw Company went on to devise the Pozidrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption: Phillips screw head. The following is an infobox which accompanies this article. Infobox: Part of the series on screw drive types. Slotted, commonly erroneously flathead, Phillips, crosshead, Pozidrive, superdrive, torques, hex, Allen, Robertson, triwing, torque set, spanner head, triple square, XZN, others, polydrive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the 9th of April, 2008 at 17:04. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a US registered 501(c)3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/copyleft/fdl.html."
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          }
-        ]
       }
     ],
     "arch":"Gemma-4 E2B audio",
@@ -5873,13 +5650,13 @@
         ]
       },
       {
-        "engine":"das",
+        "engine":"whisper-cli",
         "backend":"metal",
-        "flavor":"tuned",
+        "flavor":"stock",
         "box":"m4",
         "threads":10,
         "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-tiny.bin -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
+        "cmd":"~/whisper.cpp/build/bin/whisper-cli -m ~/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 10 -bs 1 -bo 1",
         "hardware":{
           "cpu":"Apple M4 Pro",
           "arch":"arm64",
@@ -5893,53 +5670,31 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":42.091000000000001,
-            "audio_s":11,
-            "encode_ms":22.661999999999999,
-            "text":" And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":51.330000000000005
           },
           "asr:jfk3.wav":{
-            "ms":101.517,
-            "audio_s":33,
-            "encode_ms":48.914999999999999,
-            "text":" And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":122.10999999999999
           },
           "asr:gb1.wav":{
-            "ms":532.49699999999996,
-            "audio_s":198.734375,
-            "encode_ms":213.96799999999999,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control and Houston lost contact with our Space Shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia's lost. There are no survivors. And board was a crew of seven, Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Cooltna Chavla, and Elon Ramon, a Colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock in grief. You're not alone. Our entire nation agrees with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Man kind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. As farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens who created all these, He who brings out the story hosts one by one and calls them each by name, because of His great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth yet we can pray that all are safely home. May God bless the grieving families and may God continue to bless America. [BLANK_AUDIO]"
+            "ms":683.98000000000002
           },
           "asr:hp0.wav":{
-            "ms":675.56200000000001,
-            "audio_s":273.28724999999997,
-            "encode_ms":270.67200000000003,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used power to screw drivers. Phillips Major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the Pawsadrive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompanied this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A U.S. registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html."
+            "ms":800.20999999999992
           },
           "asr:hp0x2.wav":{
-            "ms":1336.0650000000001,
-            "audio_s":546.57449999999994,
-            "encode_ms":584.16399999999999,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used power to screw drivers. Phillips Major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the Pawsadrive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompanied this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A U.S. registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html. Henry F Phillips from Wikipedia, the free The Korean Cyclopedia at EN. Wikipedia.org Henry F. Phillips From Wikipedia, the Korean Cyclopedia Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Philips' head screw and screwdriver named after him. The importance of the cross head screw design lies in its self-centering property, useful on automated production lines that use powered screw drivers. Philips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343, US patents 2,046,837 to 2,046,847 840. It was so widely copied that by 1949, Phillips lost his patent. The American screw company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw. As distinct from the simple mild slot of a slotted type screw. The Phillips screw company and the American screw company went on to devise the Pawsadrive screw which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article caption \"Philips Screwhead\". The following is an info box which accompanies this article. In a info box part of the series on screw drive types. Slaughted, commonly, erroneously, flat head. Phillips, cross head. Paws of Drive, Super Drive. Torx, Hex, Allen, Robertson, Tri-wing, Torxet, Spannerhead, Triple Square, XZN, Others, Polydrive, Spline Drive, Double Hacks, Many images accompanied this infobox. This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the Gnue-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Inc. A U.S. registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html."
+            "ms":1609.6300000000001
           }
         },
         "workload":"asr",
         "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
+        "versions":"whisper.cpp @ 6fc7c33b4",
+        "exec_fmt":"q8_0",
         "files":[
           {
             "role":"weights",
-            "name":"ggml-tiny.bin",
-            "sha256":"be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21",
-            "bytes":77691713
+            "name":"ggml-tiny-q8_0.bin",
+            "sha256":"c2085835d3f50733e2ff6e4b41ae8a2b8d8110461e18821b09a15c40c42d1cca",
+            "bytes":43537433
           },
           {
             "role":"clip",
@@ -5972,15 +5727,22 @@
             "bytes":17490462
           }
         ]
-      },
+      }
+    ],
+    "arch":"Whisper tiny",
+    "size_bytes":77691713
+  },
+  {
+    "gguf":"ggml-large-v3-turbo.bin",
+    "runs":[
       {
-        "engine":"whisper-cli",
-        "backend":"metal",
-        "flavor":"stock",
+        "engine":"das",
+        "backend":"cpu",
+        "flavor":"tuned",
         "box":"m4",
         "threads":10,
         "date":"2026-09-23",
-        "cmd":"~/whisper.cpp/build/bin/whisper-cli -m ~/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 10 -bs 1 -bo 1",
+        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-large-v3-turbo.bin -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json",
         "hardware":{
           "cpu":"Apple M4 Pro",
           "arch":"arm64",
@@ -5994,96 +5756,10 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":51.330000000000005
-          },
-          "asr:jfk3.wav":{
-            "ms":122.10999999999999
-          },
-          "asr:gb1.wav":{
-            "ms":683.98000000000002
-          },
-          "asr:hp0.wav":{
-            "ms":800.20999999999992
-          },
-          "asr:hp0x2.wav":{
-            "ms":1609.6300000000001
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "versions":"whisper.cpp @ 6fc7c33b4",
-        "exec_fmt":"q8_0",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-tiny-q8_0.bin",
-            "sha256":"c2085835d3f50733e2ff6e4b41ae8a2b8d8110461e18821b09a15c40c42d1cca",
-            "bytes":43537433
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      }
-    ],
-    "arch":"Whisper tiny",
-    "size_bytes":77691713
-  },
-  {
-    "gguf":"ggml-large-v3-turbo.bin",
-    "runs":[
-      {
-        "engine":"das",
-        "backend":"cpu",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-large-v3-turbo.bin -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":1249.1479999999999,
-            "audio_s":11,
-            "encode_ms":1183.8399999999999,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
+            "ms":1249.1479999999999,
+            "audio_s":11,
+            "encode_ms":1183.8399999999999,
+            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
           },
           "asr:jfk3.wav":{
             "ms":2557.1320000000001,
@@ -6378,107 +6054,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-large-v3-turbo.bin -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":504.94,
-            "audio_s":11,
-            "encode_ms":441.49099999999999,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":1063.703,
-            "audio_s":33,
-            "encode_ms":883.54100000000005,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":4575.576,
-            "audio_s":198.734375,
-            "encode_ms":3534.2539999999999,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kultna Shavla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when spaceflight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, \"Lift your eyes and look to the heavens, who created all these. He who brings out the starry hosts one by one and calls them each by name. Because of His great power and mighty strength, not one of them is missing.\" The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families, and may God continue to bless America. Thank you."
-          },
-          "asr:hp0.wav":{
-            "ms":6574.8400000000001,
-            "audio_s":273.28724999999997,
-            "encode_ms":5305.4690000000001,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          },
-          "asr:hp0x2.wav":{
-            "ms":12653.338,
-            "audio_s":546.57449999999994,
-            "encode_ms":10234.632,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, Available at www.gnu.org slash copyleft slash fdl.html Henry F. Phillips From Wikipedia, the free encyclopedia at en.wikipedia.org Henry F. Phillips, 1890-1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the crosshead concept forward, to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex Allen, Robertson, Tri-Wing, Torxet, Spannerhead, Triple Square, XZN. Others, Poly Drive, Spline Drive, Double Hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-large-v3-turbo.bin",
-            "sha256":"1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69",
-            "bytes":1624555275
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"metal",
@@ -7034,89 +6609,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m canary-qwen-2.5b-decoder-q8_0.gguf -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":502.17599999999999,
-            "audio_s":11,
-            "encode_ms":247.83600000000001,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:jfk3.wav":{
-            "ms":1532.3140000000001,
-            "audio_s":33,
-            "encode_ms":742.65300000000002,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":11932.397999999999,
-            "audio_s":198.734375,
-            "encode_ms":10158.396000000001,
-            "text":"My fellow Americans, this day has brought terrible news and great sadness to our country. At nine o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. In the words of the prophet Isaiah, May God bless the grieving families and may God continue to bless America."
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"canary-qwen-2.5b-decoder-q8_0.gguf",
-            "sha256":"24c5f521ef7fce86f3752a9566605527921e3c534d27dd9ab262879b4690cabe",
-            "bytes":1834425984
-          },
-          {
-            "role":"mmproj",
-            "name":"canary-qwen-2.5b-encoder-f32.bin",
-            "sha256":"37d1057ced3150cfde2fb996c1fc0a3d702d23a97f9347aedb52795ebec03e5c",
-            "bytes":3252768256
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          }
-        ]
-      },
       {
         "engine":"nemo",
         "backend":"cpu",
@@ -9080,113 +8572,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m Qwen3-ASR-0.6B-Q8_0.gguf -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":197.761,
-            "audio_s":11,
-            "encode_ms":48.951000000000001,
-            "text":"And so, my fellow Americans, ask not what your country can do for you; ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":527.50599999999997,
-            "audio_s":33,
-            "encode_ms":125.20999999999999,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":4049.2089999999998,
-            "audio_s":198.734375,
-            "encode_ms":725.69500000000005,
-            "text":"My fellow Americans. This day has brought terrible news. In great sadness to our country. At nine o'clock this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Doctor Kulpina Shavla, and Elon Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket. And the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers. And they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well. Of the families of these men and women, who have been given this sudden shock in grief. You are not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude. Of this country, the cause in which they died will continue. Mankind is led into the darkness. Beyond our world, by the inspiration of discovery. And the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah. Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one. And calls them each by name. Because of his great power. And mighty strength, not one of them is missing. The same creator who names the stars. Also knows the names. Of the seven souls we mourn today. The crew of the shuttle Columbia. Did not return safely to Earth. Yet we can pray. That all are safely home. May God bless the grieving families. And may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":5593.7709999999997,
-            "audio_s":273.28724999999997,
-            "encode_ms":985.17600000000004,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. Patent Number 2,000,46,000,343, U.S. Patents 2,000,46,000,837 to 2,000,46,000,840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape, in the head of the screw. As distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company, went on to devise the Posidrive screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly erroneously flat head. Phillips cross head. Posidrive, Supadrive. Torx. Hex, Allen. Robertson. Triwing. Torxet. Spanner head. Triple square, XZN. Others, Polydrive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April 2008, at 17:04. All text is available under the terms of the GNU Free Documentation License, see copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered 501c3, tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/slash, copyleft/slash, fdl.shtml."
-          },
-          "asr:hp0x2.wav":{
-            "ms":14705.468999999999,
-            "audio_s":546.57449999999994,
-            "encode_ms":1991.6310000000001,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958. A U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. patent number 2,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00"
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-ASR-0.6B-Q8_0.gguf",
-            "sha256":"bca259818b50ca7c4c05e9bdb35a5dc04fa039653a6d6f3f0f331f96f6aa1971",
-            "bytes":804749248
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-ASR-0.6B-bf16.gguf",
-            "sha256":"dae36c855f9a82a8916bea2238b24bda69a39d8da8b2f46dee7c103775656039",
-            "bytes":378575520
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
diff --git a/modules/dasLLAMA/performance/records/m5.json b/modules/dasLLAMA/performance/records/m5.json
index 490d2c2f68..8a17da6a4b 100644
--- a/modules/dasLLAMA/performance/records/m5.json
+++ b/modules/dasLLAMA/performance/records/m5.json
@@ -296,70 +296,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf --image-mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E2B-it-bf16.gguf --image ~/Work/llama.cpp/models/coco-val2017-000000039769.jpg -r 3 -t 6 -o json --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":37.496000000000002
-          },
-          "img:pp":{
-            "tok_s":5775.8524936132399
-          },
-          "img:tg":{
-            "tok_s":153.81460213289583,
-            "text":": This is an image of two tabby cats lying on a pink surface."
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"027907cc8",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"cpu",
@@ -543,101 +479,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m gemma-4-E2B-it-Q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":232.15100000000001,
-            "audio_s":11,
-            "encode_ms":34.542000000000002,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":626.00599999999997,
-            "audio_s":33,
-            "encode_ms":96.992999999999995,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:gb1.wav":{
-            "ms":4283.308,
-            "audio_s":198.734375,
-            "encode_ms":539.28200000000004,
-            "text":"Fellow Americans, this day has brought terrible news and great sadness to our country. At 9:00 this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kulpna Shawla, and Elaine Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity in an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce atmosphere of the Earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens, who created space, he who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families and may God may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":5509.0820000000003,
-            "audio_s":273.28724999999997,
-            "encode_ms":784.60400000000004,
-            "text":"Henry F. Phillips from Wikipedia, the free encyclopedia at en.wikipedia.org. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips major contribution was in driving the crosshead concept forward to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, US patent number 2,46343, US patents 2,46837 to 2,46840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screwmakers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips screw company and the American Screw Company went on to devise the Pozidrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption: Phillips screw head. The following is an infobox which accompanies this article. Infobox: Part of the series on screw drive types. Slotted, commonly erroneously flathead, Phillips, crosshead, Pozidrive, superdrive, torques, hex, Allen, Robertson, triwing, torque set, spanner head, triple square, XZN, others, polydrive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the 9th of April, 2008 at 17:04. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a US registered 501(c)3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/copyleft/fdl.html."
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -1853,70 +1694,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/Work/llama.cpp/models/gemma-4-E4B-it-Q8_0.gguf --image-mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E4B-it-BF16.gguf --image ~/Work/llama.cpp/models/coco-val2017-000000039769.jpg -r 3 -t 6 -o json --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":38.258000000000003
-          },
-          "img:pp":{
-            "tok_s":3469.7508896797153
-          },
-          "img:tg":{
-            "tok_s":88.238619286204724,
-            "text":"The user wants a one-sentence description of the provided image.\nThe image contains two cats lying on a pink surface.\n\nPlan: Describe the main subjects"
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"027907cc8",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E4B-it-Q8_0.gguf",
-            "sha256":"34be82b17b4942d389b9b527170c4b058027abdd32531fda063d3d97dd8ce80a",
-            "bytes":8031242688
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E4B-it-BF16.gguf",
-            "sha256":"f77995e4b6a569ab8f0d1bfdb7e8da4a0fa5b9e6f309b9bf3bdb76164d75e29f",
-            "bytes":991552256
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"cpu",
@@ -6054,13 +5831,13 @@
         ]
       },
       {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
+        "engine":"whisper-cli",
+        "backend":"cpu",
+        "flavor":"stock",
         "box":"m5",
         "threads":6,
         "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-tiny.bin -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
+        "cmd":"../whisper.cpp/build/bin/whisper-cli -m ../whisper.cpp/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 6 -bs 1 -bo 1 -nf -ng",
         "hardware":{
           "cpu":"Apple M5 Max",
           "arch":"arm64",
@@ -6074,53 +5851,31 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":34.768999999999998,
-            "audio_s":11,
-            "encode_ms":18.687999999999999,
-            "text":" And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":73.739999999999995
           },
           "asr:jfk3.wav":{
-            "ms":86.671000000000006,
-            "audio_s":33,
-            "encode_ms":35.045000000000002,
-            "text":" And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":168.50999999999999
           },
           "asr:gb1.wav":{
-            "ms":508.22500000000002,
-            "audio_s":198.734375,
-            "encode_ms":184.029,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control and Houston lost contact with our Space Shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia's lost. our no survivors. On board was a crew of seven, Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McHool, Dr. Kultner Chavla, and Elon Ramon, a Colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the earth. These astronauts knew the dangers and they faced them willingly. knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock in grief. You're not alone. Our entire nation agrees with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. in the skies today, we saw destruction and tragedy. As farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens, who created all these, he who brings out the story hosts one by one, and calls them each by name, because of his great power and mighty strength, not one of them is missing. The same creator who names the stars, also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families. and make out what may God continue to bless America."
+            "ms":884.63999999999999
           },
           "asr:hp0.wav":{
-            "ms":571.58399999999995,
-            "audio_s":273.28724999999997,
-            "encode_ms":202.53,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia, at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used powered screwdrivers. Phillips major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the positive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-Wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompany this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A US registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html."
+            "ms":1226.1299999999999
           },
           "asr:hp0x2.wav":{
-            "ms":1164.951,
-            "audio_s":546.57449999999994,
-            "encode_ms":439.428,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia, at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used powered screwdrivers. Phillips major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the positive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-Wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompany this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A US registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html. Henry F Phillips from Wikipedia, the free The Korean Cyclopedia at EN. Wikipedia.org Henry F. Phillips From Wikipedia, the Korean Cyclopedia Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Philips' head screw and screwdriver named after him. The importance of the cross head screw design lies in its self-centering property, useful on automated production lines that use powered screw drivers. Philips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343, US patents 2,046,837 to 2,046,847 840. It was so widely copied that by 1949, Phillips lost his patent. The American screw company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw. As distinct from the simple mild slot of a slotted type screw. The Phillips screw company and the American screw company went on to devise the Pawsadrive screw which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article caption \"Philips Screwhead\". The following is an info box which accompanies this article. In the info box part of the series on screw drive types. Slaughted, commonly, erroneously, flat head. Phillips, cross head. Paws of Drive, Super Drive. Torx, Hex, Allen, Robertson, Tri-wing, Torxet, Spannerhead, Triple Square, XZN, Others, Polydrive, Spline Drive, Double Hex. Many images accompanied this info box. This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the Gnue-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Inc. a US registered 501c3 tax deductible nonprofit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License. Available at www.gnu.org/copyleft/fdl.a THTML"
+            "ms":2446.8900000000003
           }
         },
         "workload":"asr",
         "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"5bb0cdbbe45233cc8ea5a048c6a9239940308c1dcce98291e1dd702421f3d3f8",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
+        "versions":"whisper.cpp @ 6fc7c33b4",
+        "exec_fmt":"q8_0",
         "files":[
           {
             "role":"weights",
-            "name":"ggml-tiny.bin",
-            "sha256":"be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21",
-            "bytes":77691713
+            "name":"ggml-tiny-q8_0.bin",
+            "sha256":"c2085835d3f50733e2ff6e4b41ae8a2b8d8110461e18821b09a15c40c42d1cca",
+            "bytes":43537433
           },
           {
             "role":"clip",
@@ -6156,12 +5911,12 @@
       },
       {
         "engine":"whisper-cli",
-        "backend":"cpu",
+        "backend":"metal",
         "flavor":"stock",
         "box":"m5",
         "threads":6,
         "date":"2026-09-23",
-        "cmd":"../whisper.cpp/build/bin/whisper-cli -m ../whisper.cpp/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 6 -bs 1 -bo 1 -nf -ng",
+        "cmd":"../whisper.cpp/build/bin/whisper-cli -m ../whisper.cpp/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 6 -bs 1 -bo 1",
         "hardware":{
           "cpu":"Apple M5 Max",
           "arch":"arm64",
@@ -6175,19 +5930,19 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":73.739999999999995
+            "ms":45.36999999999999
           },
           "asr:jfk3.wav":{
-            "ms":168.50999999999999
+            "ms":89.709999999999994
           },
           "asr:gb1.wav":{
-            "ms":884.63999999999999
+            "ms":505.59000000000003
           },
           "asr:hp0.wav":{
-            "ms":1226.1299999999999
+            "ms":582.85000000000002
           },
           "asr:hp0x2.wav":{
-            "ms":2446.8900000000003
+            "ms":1157.97
           }
         },
         "workload":"asr",
@@ -6234,92 +5989,13 @@
         ]
       },
       {
-        "engine":"whisper-cli",
-        "backend":"metal",
+        "engine":"onnx",
+        "backend":"cpu",
         "flavor":"stock",
         "box":"m5",
         "threads":6,
         "date":"2026-09-23",
-        "cmd":"../whisper.cpp/build/bin/whisper-cli -m ../whisper.cpp/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 6 -bs 1 -bo 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":45.36999999999999
-          },
-          "asr:jfk3.wav":{
-            "ms":89.709999999999994
-          },
-          "asr:gb1.wav":{
-            "ms":505.59000000000003
-          },
-          "asr:hp0.wav":{
-            "ms":582.85000000000002
-          },
-          "asr:hp0x2.wav":{
-            "ms":1157.97
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "versions":"whisper.cpp @ 6fc7c33b4",
-        "exec_fmt":"q8_0",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-tiny-q8_0.bin",
-            "sha256":"c2085835d3f50733e2ff6e4b41ae8a2b8d8110461e18821b09a15c40c42d1cca",
-            "bytes":43537433
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
-      {
-        "engine":"onnx",
-        "backend":"cpu",
-        "flavor":"stock",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/benchmarks/asr/.venv-onnx/bin/python modules/dasLLAMA/benchmarks/asr/onnx_bench.py --variant whisper-tiny-int8 --out modules/dasLLAMA/benchmarks/asr/_pybench_rows.txt --threads 6 --reps 2 --wav modules/dasLLAMA/benchmarks/asr/corpus/jfk.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/jfk3.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/hp0.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav",
+        "cmd":"modules/dasLLAMA/benchmarks/asr/.venv-onnx/bin/python modules/dasLLAMA/benchmarks/asr/onnx_bench.py --variant whisper-tiny-int8 --out modules/dasLLAMA/benchmarks/asr/_pybench_rows.txt --threads 6 --reps 2 --wav modules/dasLLAMA/benchmarks/asr/corpus/jfk.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/jfk3.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/hp0.wav --wav modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav",
         "hardware":{
           "cpu":"Apple M5 Max",
           "arch":"arm64",
@@ -6559,107 +6235,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-large-v3-turbo.bin -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":139.648,
-            "audio_s":11,
-            "encode_ms":100.104,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":311.93599999999998,
-            "audio_s":33,
-            "encode_ms":199.636,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":1468.098,
-            "audio_s":198.734375,
-            "encode_ms":797.19299999999998,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kultna Shavla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when spaceflight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, \"Lift your eyes and look to the heavens, who created all these. He who brings out the starry hosts one by one and calls them each by name. Because of His great power and mighty strength, not one of them is missing.\" The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families, and may God continue to bless America. Thank you."
-          },
-          "asr:hp0.wav":{
-            "ms":1999.721,
-            "audio_s":273.28724999999997,
-            "encode_ms":1208.355,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          },
-          "asr:hp0x2.wav":{
-            "ms":3860.2979999999998,
-            "audio_s":546.57449999999994,
-            "encode_ms":2304.7379999999998,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, Available at www.gnu.org slash copyleft slash fdl.html Henry F. Phillips From Wikipedia, the free encyclopedia at en.wikipedia.org Henry F. Phillips, 1890-1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the crosshead concept forward, to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex Allen, Robertson, Tri-Wing, Torxet, Spannerhead, Triple Square, XZN. Others, Poly Drive, Spline Drive, Double Hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"5bb0cdbbe45233cc8ea5a048c6a9239940308c1dcce98291e1dd702421f3d3f8",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-large-v3-turbo.bin",
-            "sha256":"1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69",
-            "bytes":1624555275
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"cpu",
@@ -6863,89 +6438,6 @@
   {
     "gguf":"canary-qwen-2.5b-decoder-q8_0.gguf",
     "runs":[
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m canary-qwen-2.5b-decoder-q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":321.988,
-            "audio_s":11,
-            "encode_ms":209.85599999999999,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:jfk3.wav":{
-            "ms":892.68399999999997,
-            "audio_s":33,
-            "encode_ms":552.85299999999995,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":6502.0730000000003,
-            "audio_s":198.734375,
-            "encode_ms":5862.0429999999997,
-            "text":"My fellow Americans, this day has brought terrible news and great sadness to our country. At nine o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. In the words of the prophet Isaiah, May God bless the grieving families and may God continue to bless America."
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"5bb0cdbbe45233cc8ea5a048c6a9239940308c1dcce98291e1dd702421f3d3f8",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"canary-qwen-2.5b-decoder-q8_0.gguf",
-            "sha256":"24c5f521ef7fce86f3752a9566605527921e3c534d27dd9ab262879b4690cabe",
-            "bytes":1834425984
-          },
-          {
-            "role":"mmproj",
-            "name":"canary-qwen-2.5b-encoder-f32.bin",
-            "sha256":"37d1057ced3150cfde2fb996c1fc0a3d702d23a97f9347aedb52795ebec03e5c",
-            "bytes":3252768256
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          }
-        ]
-      },
       {
         "engine":"nemo",
         "backend":"cpu",
@@ -7235,113 +6727,6 @@
   {
     "gguf":"Qwen3-ASR-0.6B-Q8_0.gguf",
     "runs":[
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m Qwen3-ASR-0.6B-Q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":105.40000000000001,
-            "audio_s":11,
-            "encode_ms":21.899999999999999,
-            "text":"And so, my fellow Americans, ask not what your country can do for you; ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":286.846,
-            "audio_s":33,
-            "encode_ms":60.396999999999998,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":1979.1700000000001,
-            "audio_s":198.734375,
-            "encode_ms":332.49000000000001,
-            "text":"My fellow Americans. This day has brought terrible news. In great sadness to our country. At nine o'clock this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Doctor Kulpina Shavla, and Elon Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket. And the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers. And they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well. Of the families of these men and women, who have been given this sudden shock in grief. You are not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude. Of this country, the cause in which they died will continue. Mankind is led into the darkness. Beyond our world, by the inspiration of discovery. And the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah. Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one. And calls them each by name. Because of his great power. And mighty strength, not one of them is missing. The same creator who names the stars. Also knows the names. Of the seven souls we mourn today. The crew of the shuttle Columbia. Did not return safely to Earth. Yet we can pray. That all are safely home. May God bless the grieving families. And may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":2723.636,
-            "audio_s":273.28724999999997,
-            "encode_ms":451.142,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. Patent Number 2,000,46,000,343, U.S. Patents 2,000,46,000,837 to 2,000,46,000,840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape, in the head of the screw. As distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company, went on to devise the Posidrive screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly erroneously flat head. Phillips cross head. Posidrive, Supadrive. Torx. Hex, Allen. Robertson. Triwing. Torxet. Spanner head. Triple square, XZN. Others, Polydrive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April 2008, at 17:04. All text is available under the terms of the GNU Free Documentation License, see copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered 501c3, tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/slash, copyleft/slash, fdl.shtml."
-          },
-          "asr:hp0x2.wav":{
-            "ms":7310.8400000000001,
-            "audio_s":546.57449999999994,
-            "encode_ms":931.44100000000003,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958. A U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. patent number 2,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00"
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-ASR-0.6B-Q8_0.gguf",
-            "sha256":"bca259818b50ca7c4c05e9bdb35a5dc04fa039653a6d6f3f0f331f96f6aa1971",
-            "bytes":804749248
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-ASR-0.6B-bf16.gguf",
-            "sha256":"dae36c855f9a82a8916bea2238b24bda69a39d8da8b2f46dee7c103775656039",
-            "bytes":378575520
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -7709,113 +7094,6 @@
   {
     "gguf":"Qwen3-Omni-30B-A3B-Instruct-Q8_0.gguf",
     "runs":[
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m Qwen3-Omni-30B-A3B-Instruct-Q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":400.69200000000001,
-            "audio_s":11,
-            "encode_ms":37.390000000000001,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":482.27499999999998,
-            "audio_s":33,
-            "encode_ms":98.787000000000006,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":6080.7200000000003,
-            "audio_s":198.734375,
-            "encode_ms":546.71600000000001,
-            "text":"My fellow Americans, this day has brought terrible news and great sadness to our country. At nine o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kalpana Chawla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, \"Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing.\" The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families, and may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":8007.5699999999997,
-            "audio_s":273.28724999999997,
-            "encode_ms":803.96299999999997,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en dot wikipedia dot org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, eighteen ninety to nineteen fifty eight, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines, that use powered screwdrivers. Phillips major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in nineteen thirty six, U.S. patent number two million forty six thousand, three hundred forty three, U.S. patents two million forty six thousand, eight hundred thirty seven, to two million forty six thousand, eight hundred forty. It was so widely copied, that by nineteen forty nine, Phillips lost his patent. The American Screw Company, was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the nineteen thirties dismissed the Phillips concept, since it calls for a relatively complex, recessed socket shape, in the head of the screw. As distinct from the simple milled slot, of a slotted type screw. The Phillips Screw Company, and the American Screw Company, went on to devise the Pozidriv screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an infobox which accompanies this article. Infobox, part of the series on screw drive types. Slotted, commonly erroneously flathead. Phillips, crosshead. Pozidriv, Supadriv. Torx. Hex, Allen. Robertson. Tri-wing. Torx set. Spanner head. Triple square, XZN. Others, Polydrive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the ninth of April, two thousand eight, at seventeen oh four. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered five hundred one C three, tax deductible nonprofit charity. This sound file and all text in the article, are licensed under the GNU Free Documentation License, available at www dot g n u dot org slash copyleft slash f d l dot h t m l."
-          },
-          "asr:hp0x2.wav":{
-            "ms":21452.121999999999,
-            "audio_s":546.57449999999994,
-            "encode_ms":1623.6020000000001,
-            "text":"Henry F Phillips from Wikipedia, the free encyclopedia at en dot wikipedia dot org. Henry F Phillips from Wikipedia, the free encyclopedia. Henry F Phillips, eighteen ninety to nineteen fifty eight, a U S businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines, that use powered screwdrivers. Phillips major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in nineteen thirty six, U S patent number two million forty six thousand, three hundred forty three, U S patents two million forty six thousand, eight hundred thirty seven, to two million forty six thousand, eight hundred forty. It was so widely copied, that by nineteen forty nine, Phillips lost his patent. The American Screw Company, was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the nineteen thirties dismissed the Phillips concept, since it calls for a relatively complex, recessed socket shape, in the head of the screw. As distinct from the simple milled slot, of a slotted type screw. The Phillips Screw Company, and the American Screw Company, went on to devise the Pozidriv screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an infobox which accompanies this article. Infobox, part of the series on screw drive types. Slotted, commonly erroneously flathead. Phillips, crosshead. Pozidriv, Supadriv. Torx. Hex, Allen. Robertson. Tri wing. Torx set. Spanner head. Triple square, XZN. Others, Poly Drive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the ninth of April, two thousand eight, at seventeen oh four. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U S registered five hundred and one C three, tax deductible nonprofit charity. This sound file and all text in the article, are licensed under the GNU Free Documentation License, available at, w w w dot g n u dot org slash copyleft slash f d l dot h t m l. Henry F Phillips, from Wikipedia, the free encyclopedia, at en dot wikipedia dot org. Henry F Phillips. From Wikipedia, the free encyclopedia. Henry F Phillips, eighteen ninety to nineteen fifty eight, a U S businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines, that use powered screwdrivers. Phillips major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in nineteen thirty six, U S patent number two million forty six thousand, three hundred forty three, U S patents two million forty six thousand, eight hundred thirty seven, to two million forty six thousand, eight hundred forty. It was so widely copied, that by nineteen forty nine, Phillips lost his patent. The American Screw Company, was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the nineteen thirties dismissed the Phillips concept, since it calls for a relatively complex, recessed socket shape, in the head of the screw. As distinct from the simple milled slot, of a slotted type screw. The Phillips Screw Company, and the American Screw Company, went on to devise the Pozidriv screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an infobox which accompanies this article. Infobox, part of the series on screw drive types. Slotted, commonly erroneously flathead. Phillips, crosshead. Pozidriv, Supadriv. Torx. Hex, Allen. Robertson. Tri wing. Torx set. Spanner head. Triple square, XZN. Others, Poly Drive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the ninth of April, two thousand eight, at seventeen oh four. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U S registered five hundred and one C three, tax deductible nonprofit charity. This sound file and all text in the article, are licensed under the GNU Free Documentation License, available at, w w w dot g n u dot org slash copyleft slash f d l dot h t m l."
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-Omni-30B-A3B-Instruct-Q8_0.gguf",
-            "sha256":"8a50e5a7d29ae6a28fea9ca45e3bb0a142e76ec07e6787a7703cd498eb08ffaa",
-            "bytes":32484494336
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-Omni-30B-A3B-Instruct-bf16.gguf",
-            "sha256":"f0dfe825fb692d426362b1ac79678fc08daa4758f7151526cad110515f122883",
-            "bytes":2207465568
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
diff --git a/modules/dasLLAMA/tests/CLAUDE.md b/modules/dasLLAMA/tests/CLAUDE.md
index 48d64a28b4..3fcf44644c 100644
--- a/modules/dasLLAMA/tests/CLAUDE.md
+++ b/modules/dasLLAMA/tests/CLAUDE.md
@@ -243,9 +243,14 @@ twin-knob freeze and whisper's own wblob-ONLY poison that must CHANGE the GPU tr
 (both legs are whisper's alone; qwen3a carries neither; a twin-W route reads its GEMM weights
 from `wblob` alone, so zeroing that buffer alone poisons it, while a route that also reads the
 f32 plane, `fblob`, is poisoned only with both zeroed), the gemma4a Metal
-Conformer cell (f32-lane transcript equality CPU vs GPU + encode rel-l2 + counter deltas -
-the lane pin/reset discipline mirrors qwen3a's), the canary Metal FastConformer cell (the
-same discipline over the rel-pos XL block loop; decoder = the q8_0 serving artifact), the
+Conformer cells, E2B and E4B (f32-lane transcript equality CPU vs GPU + the soft tokens' rel-l2 +
+counter deltas, the projector tail run on the device - `out_ready` set on the device leg and clear
+on the CPU leg - and the two projector widths read off the file: the encoder's 1536 on both, the
+embedder's 1536 on E2B and 2560 on E4B; the lane pin/reset discipline mirrors qwen3a's), the canary Metal FastConformer cell (the
+same discipline over the rel-pos XL block loop, the mel and the subsample front served on the
+device ahead of it - the conv counter rising - and the control a clip with half its windowed
+frames silenced, which the per-feature normalization cannot absorb as it would a scaled clip;
+decoder = the q8_0 serving artifact), the
 parakeet Metal FastConformer cell (the same chain over parakeet's f32 blob, minted in memory;
 transcript equality CPU vs GPU + the encoder rows' rel-l2 + counter deltas - the subsample front
 counted on the device at every GPU encode - then the front lever off (`set_metal_parakeet_front`:
@@ -256,11 +261,14 @@ forms under the `mulmm_q8,attn_dev` crown - every head at once, its engage count
 (`metal_tower_fc_dev_encodes`) and its transcript the CPU's, and the per-head loop with the lever
 off (`set_metal_fc_attn_dev`), the counter unmoved, the two forms' distances from the CPU rail
 asserted to differ; the crowns and the three levers are put back as the cell found them), plus
-the tower q8-decline - a q8 whisper encoder never dispatches and records the `quant_mode`
-decline, and the whisper serving default IS q8 unless `set_asr_fp32` / `set_asr_tower_fp32`
-asks for f32 (whisper carries no lane policy). Canary, parakeet and gemma4a do: un-pinned,
-their lane follows whether the Metal tower would serve.
-Then the required-mode panic cell; the arm's DECODER half is the `test_whisper_metal_cross_kv`
+the whisper q8 lane on the tower - a q8 whisper encoder serves on the device off its q8 planes:
+the transcript the CPU q8 chain's, one encode and n_layer blocks counted, no `quant_mode` decline,
+the halfword twin's counter unmoved, and a q8 tower with one layer's planes zeroed reading another
+text through the device chain (the control); the whisper serving default IS q8 unless
+`set_asr_fp32` / `set_asr_tower_fp32` asks for f32 (whisper carries no lane policy). Canary,
+parakeet and gemma4a do: un-pinned, their lane follows whether the Metal tower would serve, and
+their q8 lane declines `quant_mode`. The required-mode panic rides the parakeet q8 cell: that
+decline under `MetalMode.required` panics; the arm's DECODER half is the `test_whisper_metal_cross_kv`
 cell in `test_model_image.das` - GPU cross-KV on the q8 serving default, transcript-exact
 against the CPU chain with window/step counter deltas and the knob and quant_mode declines,
 required-mode, step-floor and shutdown-re-arm contract; the voxtral arm re-saves a
@@ -405,7 +413,15 @@ front's cells (the same file): the first conv and the depthwise conv on an 11 x
 along one axis, even along the other, so each edge drops its own taps - against the in-test
 loops, the sums asserted to take both signs so the first conv's ReLU and the depthwise conv's
 lack of one both show; the feature permute bit for bit with its row pad zero under a sentinel
-fill; the bias-and-ReLU row pass against max(x + b, 0) over sums of both signs. The FastConformer
+fill; the bias-and-ReLU row pass against max(x + b, 0) over sums of both signs. The whisper-class projector tail's
+two row kernels (`tw_tail_rows_gate`): the pair pool and the row-split gate at a 70-wide row over
+five rows against their host forms, the gate's fixture asserted to tell its halves apart; the vision
+tails' row kernels - the grid mean pool (`tw_pool2d_gate`: a 6 x 4 row grid pooled 2 x 2 against the
+host mean, a one-axis pool told apart) and the standardize (`tw_affine_gate`: in place against
+(x * scale - b) * m, two rows past the run kept, the form with no scale told apart). Canary's mel
+normalization (`cn_melnorm`): the log and the per-feature normalization in place against a double
+form at 70 features (off the 64-thread group), 11 frames of which 7 are valid - the rest zero - and
+two rows past the mel left as they were. The FastConformer
 all-heads attention's two stamps (the same file): the half operands (`fc_twin`) bit for bit the RNE
 narrow of the host's sum or product over all five panels, their pad rows zero, one poisoned input
 a panel; the rel-shift softmax (`fc_pexp`) over two heads at 24 and 300 keys - the weights within
@@ -997,12 +1013,36 @@ past the fast cap taking the reference.
 `test_chat.das` - stocked suite; the chat template renderer per family against pinned token
 streams (each cell skips without its carrier; the Qwen2.5 cell also holds `render_turn_marked`'s
 opening - the system turn on a first turn, none on a later one, its tokens the pinned ChatML
-prefill stream), the tool wires, and the gemma-4 E2B cells: the
+prefill stream), the tool wires (the Qwen2.5 hermes cell holding the system turn a ChatML template
+states for a conversation that opens with none - its text read off the template's escaped string
+literal, its tokens ahead of the first user turn), the audio marker cells (voxtral's opening
+marker, qwen2audio's pair, and the splice at the text offset the message gives - ahead of the text,
+inside it, after it - the head and tail carrying exactly the text on their side), the inline-span cell
+(`test_chat_inline_span`: a turn marked with `add_user_span_` renders the splice pair's head, the span's
+position ids and its tail as one stream at each text offset, a replayed turn keeps its span, and a position
+id is no token id and differs by row and by key; `test_chat_span_refusals`: a span of no rows, an image or a
+marked audio span on a template with no such marker, and a span ahead of the one before it each panic, a bare
+audio span and a span at the last one's offset the controls), and the gemma-4 E2B cells: the
 thinking renderer pins (the instruct prefill token for token, the gate + bare opener, the
 thinking-off extras on `effective_stop_ids`, a mid-conversation toggle staying instruct) and
 the instruct-mode TEXT turn through `respond` (greedy "2+2": the answer, no channel marker in
 the content half, the turn ending on a stop - red when the guard does not end the turn on the
-stray `<channel|>` the E2B emits after its answer).
+stray `<channel|>` the E2B emits after its answer), and `test_gemma4_e_media_body`: one fused media
+body (text, the span's own text embeddings as rows, text - one prefill through `media_body_rows`
+and `eval_embd_body`) reads the last row's logits within a quarter of their peak of the same
+prompt as text / rows / text in three calls, and the same body with its ids cleared - the text
+rows under the padding token's per-layer input - reads past the peak (the control). Model-free beside them,
+`test_chatml_default_system`: the default system text read off template text and off a string
+literal, none where the span holds an expression or the template states no system turn. Beside it,
+`test_gemma4_instruct_opener`: a gemma-4 template's non-thinking generation prompt keeps the closed
+empty thought where the template writes one (the 12B form) and is the bare model turn where it does
+not (the E-series form); the E2B cells' pinned streams carry the bare opener. `test_llama_system_header`: a
+Llama-3.1+ template's system header read off the template - the cutoff line, the date the template
+fixes (3.1) or none where it has a clock (3.2), nothing on a template with no header (3.0); the
+Llama-3 prefill cell pins the date (`set_chat_date`) and holds the header ahead of the system text,
+on a conversation with no system message too, and the unpinned stream differing; its Llama-3.2 arm holds the
+template's own date where one is set, the `Environment: ipython` line ahead of the cutoff line on a turn that
+carries tools and absent without them, and the pinned date over the template's.
 `test_think_split.das` - the reply-side reasoning matcher, model-free: every
 thinking family's wire shape, whole-string and per-chunk down to 1 byte, and the
 instruct-mode stop guard (`nothink_stop_here_`): a channel marker before the reply's first
@@ -1016,7 +1056,20 @@ The SmolLM cells drop the loaded model's GPU state (`moe_gpu_drop_model`) so the
 the CPU rails under `DASLLAMA_GPU=1` too: their bit-exact claims hold on one lane, and the
 tier's device prefill, resident batch decode and CPU prefill round differently. Its two-stream
 deltanet cell needs Qwen3.5-0.8B-Q8_0 and `DASLLAMA_GPU=1` on a box whose tier serves the
-deltanet decode step, and skips otherwise. `test_scheduler_idle_quantum` holds the prefill
+deltanet decode step, and skips otherwise. `test_scheduler_media_splice` holds a media span as part of
+the prompt the prefix cache matches: a splice at the head, middle and tail equals the all-token stream;
+the non-causal flag reaches the kernel; and on a paged scheduler the text ahead of a span attaches and the
+hit stops at the span, the media stream donates, the same media asked again attaches past the span and
+reads the same stream, a request with no rows is served off the cache, other rows at the same place share
+only the text ahead of them (the control), and a rowless request on a cold cache finishes `media_lost` and
+donates nothing. Its splice arms hold the span and the text around it at one prefill call (`prefill_evals`),
+a body cut at the chunk at a call a chunk past it, and a non-causal span between text at `generate_embd`'s
+span form. `test_scheduler_span_cut`: a hit that would end inside a span attaches nothing past the span's
+start and the stream reads its own reference. `test_scheduler_span_validation`: a span of no rows, spans out
+of order or overlapping, a span off its position ids, rows of the wrong width, inline spans on a device-home
+scheduler and a splice beside inline spans each refuse, a well-formed request the control. `test_scheduler_mrope`'s
+paged leg asks the grid request twice: the second attaches the span off the cache and its session carries
+the span's rope advance (`rope_pos_delta`). `test_scheduler_idle_quantum` holds the prefill
 quantum's two sizes by the tokens one tick prefills: a lone stream's first tick takes the whole
 prompt under the idle quantum and one chunk with it off (`idle_chunk_tokens = 0`), the two streams
 token for token alike under classic prefill, both decoded in the log; a prompt admitted beside a
@@ -1720,8 +1773,18 @@ block a test opens around the engine without calling `setup_dasllama_jobque_()`
 window, mel filterbank, log-mel chunking, swapped swiglu); model-gated: the tower structure/oracle
 gates (ultravox/voxtral/omni shapes, the mtmd all-ones encode oracles - CPU-claim cells, tower
 knob pinned OFF) and the `test_encoder_blocks_gpu` cell, the qwen2audio + voxtral 32-layer
-CPU-vs-GPU blocks parity on the depth-scaled bars with counter deltas - Apple builds, `-jit`;
-skips honestly without the qwen2audio / voxtral mmprojs; and the Vulkan twins
+CPU-vs-GPU parity on the depth-scaled bars with counter deltas (the device leg runs the blocks and
+the projector tail) - Apple builds, `-jit`; skips honestly without the qwen2audio / voxtral
+mmprojs; `test_encoder_tail_gpu`, the projector tail alone, one cell a projector kind (qwen2a on
+the Omni-3B f16 mmproj, ultravox on the v0_5 1b f16 one, voxtral on the mini f32 one, each minted
+in memory): the device tail against the CPU tail over the SAME device block rows
+(`set_metal_tower_tail` off for the CPU-tail leg, put back) within 1e-3 rel-l2 (reads 1.6e-4 to
+2.1e-4), the tail counter (`metal_tower_tail_encodes`) up on the device leg alone with the blocks
+on the device on both, another mel's rows outside the bar as the control (reads 0.8 to 0.95); `test_log_mel_chunks_gpu`,
+the chat towers' chunked mel on the device mel seat - a 128-mel clip's chunk within 1e-3 of the
+CPU mel (the seat's GEMMs on the exact f32 tiles: a half tile reads a quiet bin 0.085 off), the mel
+counter (`metal_tower_mel_encodes`) up by the device leg alone, an 80-mel call off the seat's
+lattice served by the CPU with the counter unmoved, another clip's mel outside the bar; and the Vulkan twins
 `test_encoder_blocks_vulkan`, `test_gemma4a_vulkan_twin`, `test_canary_vulkan_twin` and
 `test_qwen3a_vulkan_front` (the three-way cells described under `test_vulkan_tower_kernels.das`),
 which skip without their carriers (the qwen2audio / voxtral / omni-3b f32 mmprojs, the E2B bf16
@@ -1732,7 +1795,9 @@ oracle cells (the parakeet v2 cell also runs the transcription with single-threa
 on: the team leg dispatches, the one-lane leg never does, and its tokens are the team leg's - the
 decode step's one-lane form against its team publish, both texts logged - and the session that
 read the whole clip reading its first half token for token as a fresh session does, the half clip
-over 8 tokens), the Vulkan twin `test_whisper_vulkan_twin` (whisper tiny and large-v3-turbo; the
+over 8 tokens, and two more transcriptions on the session leaving the heap where it stood -
+`heap_flat_leg`, which the canary and gemma4a oracle cells run too: a transcription frees what it
+allocates), the Vulkan twin `test_whisper_vulkan_twin` (whisper tiny and large-v3-turbo; the
 cell described under `test_vulkan_tower_kernels.das`, skipping without the ggml files, without
 jfk.wav, without a Vulkan device under `DASLLAMA_GPU=1`, on a das_metal build, and when
 interpreted), the decoder twin `test_whisper_vulkan_wdec` (tiny and large-v3-turbo on jfk, the q8
@@ -1748,7 +1813,18 @@ token and bar, the batch with its last token changed landing outside the bar as
 CPU blocks over them transcribe the all-CPU chain's text), `test_whisper_vulkan_wdec_lifetime` (tiny, one session reused the way a
 serving worker reuses one: a model drop between two transcriptions - the second serves again and reads the same; the decoder knob
 turned off between two - the second reads as a fresh knob-off session; the block hooks pinned off after a served window - no
-handoff for the CPU-encoded windows, the text of the CPU-encoder chain), the ASR knob cells (`set_asr_fp32`, `set_asr_tower_fp32` - the mixed
+handoff for the CPU-encoded windows, the text of the CPU-encoder chain), `test_parakeet_q8_0_file` (the parakeet v3 q8_0 bin loads through the same
+reader and reads jfk as the f32 bin does; skips without it), `test_whisper_q8_0_file` (a whisper.cpp q8_0 bin of tiny loads - its
+Q8_0 tensors read as each block's scale times its quants - and reads jfk as the f16 bin does; skips
+without `ggml-tiny-q8_0.bin`), `test_whisper_metal_ln_post`
+(tiny, the f32 encoder minted in memory: the blocks-with-post-norm seat declines with the tower
+off and serves with it on, one device encode counted, and the device's normed rows are the CPU
+post-norm of the device's own block rows within 1e-4 of the largest - reads 3e-7 - with the rows
+before the post-norm the control), `test_whisper_metal_wdec_flush`
+(tiny, the step's floor lifted so the Metal step serves and the window's cross-KV layouts wait on
+the device: the host layouts zeroed, a 33-row first batch hands the window to the CPU chain, the
+layouts land first and its logits match the knob-off chain's token and bar, the batch with its
+last token changed the control), the ASR knob cells (`set_asr_fp32`, `set_asr_tower_fp32` - the mixed
 f32-enc/q8-dec serving mode and its `asr_exec_fmt` stamp; the strict token-identity cell
 pins the simdgroup lane, and its tolerance-graded twin pins the crowns ON and asserts WORD
 equality - the tensor twins' quality gate), the q8-gate CPU-vs-CPU claims
@@ -1816,9 +1892,11 @@ the corpus as its `%%` segments over a temp file, the row statistic and the brac
 against a fake chat server on its own thread that answers by the request's `model` field: a complete
 stream (counts, both spans past the server's 30 ms pauses, the server's own TTFT), and the four
 refusals - no usage chunk, no reply text, a reply of one token (no decode span to time), HTTP 500 -
-plus no server at the address, the follow-up row standing over complete turns and refused by a failed one, and the image cells - a file as a data URI and a missing one as none, an image question's wall and prompt tokens off the fake's buffered completion, HTTP 500 saying why, an image row standing over a file and refused without one. The speech rows
+plus no server at the address, the follow-up row standing over complete turns and refused by a failed one, and the media cells (an image row and a chat-clip row, the clip an `input_audio` part, each over a file and refused without one) - a file as a data URI and a missing one as none, an image question's wall and prompt tokens off the fake's buffered completion, HTTP 500 saying why, an image row standing over a file and refused without one. The speech rows
 run against a fake speech server on a second thread: a transcription's wall holds the server's
-300 ms pause, a failed and a blank answer say why, a row answers the text its reps read and refuses
+300 ms pause, a failed and a blank answer say why, every request of a row uploads a clip the fake
+has not heard (a WAV's four reps read `new` four times; a clip that is no WAV goes up as it is, the
+fake hears it twice and the row is refused), a row answers the text its reps read and refuses
 reps that read different texts or a text other than the one asked, and the loaded row stands while
 the fake chat turn outlasts two fast reps and is refused when the reps outlive the turn, when the
 turn carries no reply text, and when the loaded text differs from the idle one. The synthesis and
@@ -1878,7 +1956,8 @@ the `max_unreserved_size` guard that must not panic.
 `test_from_template.das` - model-free: the `[from_template]` stamp (`dasllama/dasllama_tune`) - a
 placeholder call renames to the annotation's target per stub, and the stub's signature types the
 clone so one template stamps both plane overloads.
-`test_kv_prefix.das` - stocked suite; model-free cells on a synthetic Config: the prefix cache's page
+`test_kv_prefix.das` - stocked suite; beside each attach below, the probe `prefix_match_len_` reads the
+count the attach then attaches (0 on a recurrent cache, which attaches at checkpoints); model-free cells on a synthetic Config: the prefix cache's page
 accounting, the LRU budget and the token verify, then a recurrent session's checkpoints - one
 checkpoint a donation with the page of its last row copied, the `max_states` budget, where a
 prefill stops (`prefix_checkpoint_at_`: the caller's stable opening, else the opening an earlier
@@ -2017,7 +2096,7 @@ the five fixtures vary content, not geometry; exact lane on the 2e-4 + 4e-3*toke
 q8 serving lane on its measured 3.2e-1*rms bar (27 blocks, ffn served at the layout's padded
 4352 width so every GEMM quantizes), plus the fixed-canvas panic gate and the carrier
 sniff/exec_fmt cells. On Apple builds the CPU gate pins the tower knob off, and a GPU rung
-gates two fixtures through the Metal block loop on its measured 4e-2*rms bar - engage proven
+gates two fixtures through the Metal chain (the blocks and, behind them, the projector tail) on its measured 4e-2*rms bar - engage proven
 per fixture by the encodes/blocks counters, plus the knob-off decline leg (the 72-wide heads
 restride to the attention tiles' 128 on the driver), the q8-decline leg (a PINNED-q8 tower with
 the knob ARMED must never dispatch and must record the `quant_mode` decline - its Q8_0 planes
@@ -2036,6 +2115,9 @@ the device chain must EXCEED the bar), then the exact-lane tower's `quant_mode`
 canvas only, since the exact chain at 4096 rows x 27 blocks is the cell's cost. The Vulkan rung and
 the twin skip without a Vulkan device under `DASLLAMA_GPU=1`, and on a build with das_metal, where
 the Metal driver owns the tower hooks.
+`test_gemma3v_tail_gpu` holds the device tail alone, dump-free: the soft tokens with the tail on the
+device against the CPU tail over the same device block rows (`set_metal_tower_tail` off) within 1e-3
+rel-l2 (reads 1.3e-4), the tail counter up by the device leg alone, another canvas outside the bar.
 `test_qwen3v.das` - stocked suite; the qwen3v tower tier-1 parity vs the `-p encode` dumps minted on
 f32-widened mmprojs, CPU (`qwen3vl-vision-oracle/mint.sh` + `mint_4b.sh`): the Omni leg
 (`qwen3vl_merger` no deepstack) on seven fixtures (cb96 = the pos-table downscale arm,
@@ -2120,12 +2202,18 @@ encode, the token count, the compare) all vision tier-1 tests use (the `quad` ge
 q1/q2/q3 quarter-offset probe fields live here).
 `test_audio_embedder.das` - stocked suite; model-free cells: the `AudioEmbedder` carrier's own
 arms - the no-audio refusals and the probe's 0-not-panic contract; model-gated: the gemma4a arm on
-the E2B mmproj, carrying the padding-contract cell (a 320-sample clip encodes to exactly 1 soft
-token); the pre-encoded rows seam on a plain chat (`add_user_audio_rows`: a second's clip lands
+the E2B mmproj (and the E4B mmproj's probe reading the decoder's 2560 where the encoder's width differs), carrying the padding-contract cell (a 320-sample clip encodes to exactly 1 soft
+token) and the direct-image route on the lane-named `.dlim` of the lane the box serves; the
+whisper-class tower arm (`test_audio_embedder_tower_arm`: the ultravox v0_5 1b and the
+Qwen2.5-Omni-3B f16 mmprojs - the probed width, the projector kind, a 5 s clip one chunk of 187 and
+750 rows, finite and not all zero, a reused state reading the same rows bit for bit, another clip
+the control, a 35 s clip two chunks, two more encodes leaving the heap where it stood; and the span rule off the projector, ultravox bare, qwen2.5o
+not, a missing file false); the pre-encoded rows seam on a plain chat (`add_user_audio_rows`: a second's clip lands
 25 rows, two clips append, the turn answers and consumes them, a short row block and a queued
 image panic, and the same turn with thinking off under the chat sampler preset answers - gated
 on the E2B Q4_K_M decoder + its bf16 mmproj, loaded staged, no `.dlim`), and
-the no-audio-arm refusal (SmolLM2-135M: a family with no audio markers panics).
+the no-audio-arm refusal (SmolLM2-135M: a family with no audio markers panics, and the same rows
+passed as a bare span queue).
 `test_vision_embedder.das` - stocked suite; model-free cells: the `VisionEmbedder` carrier's own
 arms over constructed carriers - the text-only (none) shape, the loader's refusals by name
 (missing file, audio-only mmproj), and the `vision_exec_fmt` lane stamp (the qwen3v q8 flag
@@ -2668,7 +2756,10 @@ stale-cache red class does not exist for it.
 
 Every `[test]` file requiring a `dasllama/*` module outside this folder, each with its reason:
 - `utils/dasllama-server/test_openai_server*.das` - require the server by bare same-dir name
-  (the hyphenated directory is unreachable by path require).
+  (the hyphenated directory is unreachable by path require). `test_openai_server_audio.das`'s
+  `test_openai_server_audio_tower` serves an ultravox mmproj on a stock Llama-3.2-1B through the
+  audio arm alone: no vision arm on stats, and a clip adding exactly its 187 rows to the text-only
+  prompt count - no marker token - with the clip after the text and ahead of it, each reply logged.
 - `utils/dasllama-server/test_worker_dispatch.das` - requires the server (`openai_server`) by
   bare same-dir name, like the server suites beside it.
 - `utils/dasllama-server/test_server_flags.das` - requires the server's program root (`main`) and
diff --git a/modules/dasLLAMA/tests/REVIEW_PINNED_GATES.md b/modules/dasLLAMA/tests/REVIEW_PINNED_GATES.md
index 595c552048..e9e983331d 100644
--- a/modules/dasLLAMA/tests/REVIEW_PINNED_GATES.md
+++ b/modules/dasLLAMA/tests/REVIEW_PINNED_GATES.md
@@ -29,8 +29,13 @@ The pinned set, one entry a line, each with what it must keep holding:
   a run that prints no row names why and reads 0; and the committed stores' batched receipts - the
   cpu legs' das child at `--npl-plen 128 --npl-reps 3` and reference at `-npp 128`,
   `--no-op-offload` on the stock cpu arm alone, the metal leg at `-npp 512` with neither.
-- `test_scheduler.das`'s `test_scheduler_media_splice` cell must hold that a media stream takes no
-  cached hit at `prefix_attach` and donates no pages at `donate_stream`.
+- `test_scheduler.das`'s `test_scheduler_media_splice` cell must hold a media span's text and rows
+  as one prefill call, and a body cut at the chunk taking the rest a chunk a call; on a paged
+  scheduler, the prefix cache matching across a span by its rows' content - the text ahead of a new
+  span attaching and the hit stopping at it, the media stream donating its pages, the same span
+  asked again attaching past it, a rowless request for it served off the cache, other rows at the same place sharing only
+  the text ahead of them - and a rowless request on a cold cache finishing `media_lost` with
+  nothing donated.
 - `test_vulkan_kernels.das`'s `test_vk_coopmat_default_and_tile_pick` cell must hold which tile
   the Vulkan matmul picks, and whether that dispatch splits its reduction across partial planes,
   on every input of the prefill's tile-and-split pick.
diff --git a/modules/dasLLAMA/tests/test_audio.das b/modules/dasLLAMA/tests/test_audio.das
index 66572dcd2b..01bd98016f 100644
--- a/modules/dasLLAMA/tests/test_audio.das
+++ b/modules/dasLLAMA/tests/test_audio.das
@@ -79,14 +79,14 @@ def test_mel_filterbank(t : T?) {
 [test]
 def test_log_mel_chunks(t : T?) {
     t |> run("whisper mel: 440 Hz sine lands on its mel row, silence clamps") @(t : T?) {
-        // the mtmd-debug 'preproc 440' fixture: 5 s sine -> exactly 2 full 3000-frame chunks
+        // 5 s of sine and the 30 s of zeros past it: one full 3000-frame chunk, the partial one dropped
         var s : array<float>
         s |> resize(80000)
         for (i in range(80000)) {
             s[i] = sin(2.0 * 3.14159265 * 440.0 * float(i) / 16000.0)
         }
         let chunks <- log_mel_chunks(s, 128l)
-        t |> success(length(chunks) == 2, "two chunks (audio + padded silence)")
+        t |> equal(length(chunks), 1, "a clip under 30 s is one chunk")
         t |> equal(chunks[0].n_mel, 128l, "n_mel")
         t |> equal(chunks[0].n_len, 3000l, "n_len")
         // 440 Hz sits in the slaney linear region: center(m=18) = 19·(m_hi/129)/lin_slope ≈ 444 Hz
@@ -108,14 +108,21 @@ def test_log_mel_chunks(t : T?) {
             mx = max(mx, v)
         }
         t |> success(mx - mn <= 2.0 + 1e-6, "max-min <= 8/4 (global clamp)")
-        // the second chunk is all padded silence: every value at the clamp floor
+        // past the audio the chunk is padded silence: every value at the clamp floor
         var uniform = true
-        for (v in chunks[1].data) {
-            if (v != chunks[1].data[0]) {
-                uniform = false
+        for (m in range(128)) {
+            for (i in range(600, 3000)) {
+                if (chunks[0].data[m * 3000 + i] != chunks[0].data[600]) {
+                    uniform = false
+                }
             }
         }
-        t |> success(uniform, "silence chunk uniform at the floor")
+        t |> success(uniform, "the frames past the audio are uniform at the floor")
+        t |> success(chunks[0].data[18 * 3000 + 100] != chunks[0].data[600], "the control: a frame of the sine is off the floor")
+        // 35 s of audio: the 30 s of zeros past it complete a second chunk
+        s |> resize(560000)
+        let two <- log_mel_chunks(s, 128l)
+        t |> equal(length(two), 2, "a clip between 30 and 60 s is two chunks")
     }
 }
 
@@ -615,9 +622,9 @@ def test_qwen3a_vulkan_front(tst : T?) {
     }
 }
 
-// The GPU tower blocks vs the CPU encoder on the SAME all-ones fixture as the oracle above -
-// the projector runs CPU on both legs, so the delta isolates the 32-layer block loop (the
-// battery's deep structural check; whisper-large geometry). Counters prove the dispatch.
+// The GPU tower against the CPU encoder on one synthetic mel: the 32-layer block loop and the projector tail behind it
+// on the device leg (the battery's deep structural check; whisper-large geometry). Counters prove the dispatch; the
+// tail alone is `test_encoder_tail_gpu`'s.
 [test]
 def test_encoder_blocks_gpu(tst : T?) {
     tst |> run("qwen2audio tower: GPU blocks vs CPU encoder, 32 layers") @(t : T?) {
@@ -683,6 +690,106 @@ def test_encoder_blocks_gpu(tst : T?) {
     }
 }
 
+//! The projector tail on the device against the CPU tail over the SAME device block rows (the tail lever off), one cell a
+//! projector kind: the soft tokens within `bar` rel-l2, the tail's counter up by the device leg alone, and the rows of
+//! another mel outside the bar (the control).
+def private tail_gpu_cell(t : T?; file : string; kind : AudioProjKind; bar : float) {
+    static_if (typeinfo builtin_module_exists(das_metal)) {
+        let path = path_join(models_dir(), file)
+        return if (!jit_model_available(t, path))
+        var inscope st <- stage_audio_tower(path)
+        var tw = AudioTower()
+        mint_audio_tower(st, tw)
+        t |> success(tw.proj_kind == kind, "the projector kind the cell names")
+        var inscope mel = MelChunk(n_mel = tw.n_mel, n_len = AUDIO_CHUNK_FRAMES)
+        mel.data |> resize(tw.n_mel * AUDIO_CHUNK_FRAMES)
+        for (i in range(length(mel.data))) {
+            mel.data[i] = sin(float(i) * 0.0137) * 0.8 + sin(float(i) * 0.00291) * 0.5
+        }
+        var enc <- make_encoder_state(tw)
+        let n = audio_tokens_per_chunk(tw) * tw.proj_dim
+        let tower_was = metal_tower_knob()
+        let tail_was = metal_tower_tail_knob()
+        set_metal_tower(true)
+        with_dasllama_jobque_() {
+            set_metal_tower_tail(false)
+            let e0 = metal_tower_stats().encodes
+            let t0 = metal_tower_tail_encodes()
+            audio_encode(tw, enc, mel)
+            var inscope cpu_tail <- copy_span(enc.out, 0l, n)
+            t |> equal(metal_tower_stats().encodes - e0, 1l, "lever off: the blocks still ride the device")
+            t |> equal(metal_tower_tail_encodes() - t0, 0l, "lever off: the tail stays on the CPU")
+            set_metal_tower_tail(true)
+            audio_encode(tw, enc, mel)
+            var inscope dev_tail <- copy_span(enc.out, 0l, n)
+            t |> equal(metal_tower_tail_encodes() - t0, 1l, "lever on: the tail rides the device behind the blocks")
+            for (i in range(length(mel.data))) {
+                mel.data[i] = sin(float(i) * 0.0091) * 0.8 + sin(float(i) * 0.00417) * 0.5
+            }
+            audio_encode(tw, enc, mel)
+            var inscope other <- copy_span(enc.out, 0l, n)
+            var got = TowerParityStats()
+            var ctl = TowerParityStats()
+            if (tower_parity_stats(t, "{file} tail", cpu_tail, dev_tail, got) && tower_parity_stats(t, "{file} tail control", cpu_tail, other, ctl)) {
+                t |> success(got.rel_l2 <= double(bar), "{file}: device tail vs CPU tail rel_l2 {got.rel_l2} (bar {bar})")
+                t |> success(ctl.rel_l2 > double(bar), "{file}: another mel's rows land outside the bar (rel_l2 {ctl.rel_l2}) - the control")
+            }
+        }
+        set_metal_tower_tail(tail_was)
+        set_metal_tower(tower_was)
+        delete enc
+        delete tw
+    }
+}
+
+//! The chat towers' chunked mel on the device seat against the CPU spectrum: a 128-mel clip's chunk within 1e-3 of the CPU
+//! mel, the mel counter up by the device leg alone, an 80-mel call (off the seat's lattice) served by the CPU with the
+//! counter unmoved, and a second clip's mel outside the bar (the control).
+[test]
+def test_log_mel_chunks_gpu(t : T?) {
+    t |> run("the chunked whisper mel rides the device mel seat") @(t : T?) {
+        static_if (typeinfo builtin_module_exists(das_metal)) {
+            return if (!jit_only(t))
+            var inscope samples <- [for (i in range(16000 * 5)); 0.3 * sin(float(i) * 0.05) + 0.1 * sin(float(i) * 0.31)]
+            var inscope other <- [for (i in range(16000 * 5)); 0.3 * sin(float(i) * 0.11)]
+            let was = metal_tower_knob()
+            with_dasllama_jobque_() {
+                set_metal_tower(false)
+                let m0 = metal_tower_mel_encodes()
+                var inscope cpu <- log_mel_chunks(samples, 128l)
+                t |> equal(metal_tower_mel_encodes() - m0, 0l, "tower off: the CPU spectrum")
+                set_metal_tower(true)
+                var inscope dev <- log_mel_chunks(samples, 128l)
+                t |> equal(metal_tower_mel_encodes() - m0, 1l, "tower on: one device mel a clip")
+                var inscope dev2 <- log_mel_chunks(other, 128l)
+                var inscope m80 <- log_mel_chunks(samples, 80l)
+                t |> equal(metal_tower_mel_encodes() - m0, 2l, "an 80-mel call is off the seat's lattice: the CPU serves it")
+                t |> success(length(cpu) == 1 && length(dev) == 1 && length(m80) == 1, "one chunk each")
+                if (length(cpu) == 1 && length(dev) == 1 && length(dev2) == 1) {
+                    let d = logits_maxdiff(cpu[0].data, dev[0].data)
+                    let ctl = logits_maxdiff(cpu[0].data, dev2[0].data)
+                    t |> success(d <= 1e-3, "device mel within 1e-3 of the CPU mel (max diff {d})")
+                    t |> success(ctl > 1e-3, "another clip's mel lands outside the bar (max diff {ctl}) - the control")
+                }
+            }
+            set_metal_tower(was)
+        }
+    }
+}
+
+[test]
+def test_encoder_tail_gpu(tst : T?) {
+    tst |> run("the qwen2a tail: pair pool, post-norm, one biased linear") @(t : T?) {
+        tail_gpu_cell(t, "mmproj-Qwen2.5-Omni-3B-f16.gguf", AudioProjKind.qwen2a, 1e-3)
+    }
+    tst |> run("the ultravox tail: post-norm, stacked rms, gated MLP") @(t : T?) {
+        tail_gpu_cell(t, "mmproj-ultravox-v0_5-llama-3_2-1b-f16.gguf", AudioProjKind.ultravox, 1e-3)
+    }
+    tst |> run("the voxtral tail: pair pool, post-norm, stacked GELU MLP") @(t : T?) {
+        tail_gpu_cell(t, "voxtral-mini-mmproj-f32.gguf", AudioProjKind.voxtral, 1e-3)
+    }
+}
+
 [test]
 def test_omni_tower(t : T?) {
     t |> run("qwen2.5o mmproj: audio side is qwen2a verbatim, vision tensors skipped") @(t : T?) {
diff --git a/modules/dasLLAMA/tests/test_audio_embedder.das b/modules/dasLLAMA/tests/test_audio_embedder.das
index d2b89af0ec..eae6e96644 100644
--- a/modules/dasLLAMA/tests/test_audio_embedder.das
+++ b/modules/dasLLAMA/tests/test_audio_embedder.das
@@ -5,7 +5,8 @@ options _dasllama_internal = true
 
 // The AudioEmbedder carrier, and the pre-encoded rows seam it feeds. Skips: the gemma4a arm on
 // `mmproj-gemma-4-E2B-it-bf16.gguf` (absent file), its direct-image route on a prepared
-// gemma4a-tagged `.dlim` beside it (absent bake), the rows seam on `gemma-4-E2B-it-Q4_K_M.gguf`
+// gemma4a-tagged `.dlim` beside it (absent bake), the E4B width probe on
+// `mmproj-gemma-4-E4B-it-BF16.gguf` (absent file), the rows seam on `gemma-4-E2B-it-Q4_K_M.gguf`
 // + that mmproj (absent file), the no-audio-arm refusal on `SmolLM2-135M-Instruct-Q8_0.gguf`
 // (absent file). Every skip is loud.
 
@@ -82,17 +83,18 @@ def test_audio_embedder_gemma4a_arm(t : T?) {
             // baked family tag, or directory order hands this audio cell a vision image. The
             // load above already minted the gemma4a arm when the image rail is on, so this
             // scan only skips under DASLLAMA_IMAGE=0 — a model gate, not an artifact gate
-            if (empty(image_path) && starts_with(name, "{base_name(mm)}.0x") && ends_with(name, ".dlim")) {
+            if (empty(image_path) && starts_with(name, "{base_name(mm)}.") && ends_with(name, ".dlim")) {
                 let cand = path_join(models_dir(), name)
                 let tag = image_family_tag(cand)
                 //! only the path the rail mints for THIS box identity is loadable by the direct route - a foreign-identity bake sits beside it under its own hash
-                if (tag |> starts_with("gemma4a-") && cand == image_path_for(mm, tag)) {
+                //! and of its two lanes only the one this box serves: the direct route reads under the lane the loader picked above
+                if (tag == (e.gemma4a.q8 ? "gemma4a-q8" : "gemma4a-f32") && cand == image_path_for(mm, tag)) {
                     image_path = cand
                 }
             }
         }
         if (empty(image_path)) {
-            t |> skip("no prepared gemma4a-tagged {base_name(mm)}.0x*.dlim beside the mmproj - the direct image route needs a baked image")
+            t |> skip("no prepared gemma4a-tagged {base_name(mm)}.*.dlim beside the mmproj - the direct image route needs a baked image")
         } else {
             t |> equal(audio_probe_proj_dim(image_path), 0l, "the gguf probe answers 0 on a .dlim by pinned contract")
             var inscope ei <- load_audio_embedder(image_path)
@@ -100,6 +102,107 @@ def test_audio_embedder_gemma4a_arm(t : T?) {
             t |> equal(audio_proj_dim(ei), 1536l, "the image-loaded carrier reports the same width")
         }
     }
+    t |> run("the E4B mmproj probes its own decoder's width, read off the embedder's rows") @(t : T?) {
+        let mm = path_join(models_dir(), "mmproj-gemma-4-E4B-it-BF16.gguf")
+        if (!model_available(t, mm)) {
+            return
+        }
+        t |> equal(audio_probe_proj_dim(mm), 2560l, "the probe reports the E4B decoder width (E2B's is 1536, the encoder's 1024)")
+    }
+}
+
+def private tower_arm_cell(t : T?; file, family : string; width, rows_per_chunk : int64) {
+    let mm = path_join(models_dir(), file)
+    if (!model_available(t, mm)) {
+        return
+    }
+    t |> equal(audio_probe_proj_dim(mm), width, "the probe reports the projector's output width off its tensors")
+    var inscope e <- load_audio_embedder(mm)
+    t |> success(e.kind == AudioKind.audio_tower, "the carrier holds the whisper-class tower")
+    t |> equal(audio_family(e), family, "the carrier reports the projector kind")
+    t |> equal(audio_proj_dim(e), width, "the carrier reports the probed width")
+    var st = AudioState()
+    var samples : array<float>
+    samples |> resize(16000 * 5)
+    for (i, s in count(), samples) {
+        s = 0.3 * sin(float(i) * 0.05)
+    }
+    var rows : array<float>
+    t |> equal(encode_audio_(e, st, samples, rows), rows_per_chunk, "a 5 s clip is one mel chunk")
+    t |> equal(long_length(rows), rows_per_chunk * width, "one row of the decoder's width a soft token")
+    var peak = 0.
+    var finite = true
+    for (v in rows) {
+        finite &&= is_finite(v)
+        peak = max(peak, abs(v))
+    }
+    t |> success(finite && peak > 0., "the rows are finite and not all zero (peak {peak})")
+    var again : array<float>
+    t |> equal(encode_audio_(e, st, samples, again), rows_per_chunk, "the reused state encodes the clip again")
+    var moved = 0
+    for (a, b in rows, again) {
+        moved += a != b ? 1 : 0
+    }
+    t |> equal(moved, 0, "the reused state reads the same rows bit for bit")
+    for (i, s in count(), samples) {
+        s = 0.3 * sin(float(i) * 0.11)
+    }
+    delete again
+    encode_audio_(e, st, samples, again)
+    moved = 0
+    for (a, b in rows, again) {
+        moved += a != b ? 1 : 0
+    }
+    t |> success(moved > length(rows) / 2, "another clip reads other rows ({moved} of {length(rows)} differ) - the control")
+    samples |> resize(16000 * 35)
+    delete again
+    t |> equal(encode_audio_(e, st, samples, again), 2l * rows_per_chunk, "a 35 s clip is two chunks, their rows appended")
+    let h0 = heap_bytes_allocated()
+    for (_i in range(2)) {
+        delete again
+        encode_audio_(e, st, samples, again)
+    }
+    let h1 = heap_bytes_allocated()
+    t |> success(h1 <= h0 + 262144ul, "two more encodes leave the heap where it stood ({h0} -> {h1} bytes) - an encode frees its mel and frames")
+    delete again
+    delete rows
+    delete samples
+    delete st
+}
+
+[test]
+def test_audio_embedder_tower_arm(t : T?) {
+    t |> run("an ultravox mmproj loads as the whisper-class tower") @(t : T?) {
+        with_dasllama_jobque() {
+            tower_arm_cell(t, "mmproj-ultravox-v0_5-llama-3_2-1b-f16.gguf", "ultravox", 2048l, 187l)
+        }
+    }
+    t |> run("the span rule rides the projector: ultravox rows take no marker, the others their template's") @(t : T?) {
+        let uv = path_join(models_dir(), "mmproj-ultravox-v0_5-llama-3_2-1b-f16.gguf")
+        let omni = path_join(models_dir(), "mmproj-Qwen2.5-Omni-3B-f16.gguf")
+        if (!model_available(t, uv) || !model_available(t, omni)) {
+            return
+        }
+        t |> success(audio_probe_span_bare(uv), "an ultravox mmproj probes a bare span")
+        t |> success(!audio_probe_span_bare(omni), "a qwen2.5o mmproj does not")
+        t |> success(!audio_probe_span_bare(path_join(models_dir(), "no-such-mmproj.gguf")), "a missing file probes false, never panics")
+    }
+    t |> run("a Q8_0 projector file bakes the halfword twin its device GEMMs read") @(t : T?) {
+        let mm = path_join(models_dir(), "mmproj-Voxtral-Mini-3B-2507-Q8_0.gguf")
+        if (!model_available(t, mm)) {
+            return
+        }
+        var inscope st <- stage_audio_tower(mm)
+        t |> success(!empty(st.wblob) && length(st.wblob) == length(st.fblob), "the twin covers the f32 plane, a halfword an element ({length(st.wblob)} halves)")
+        t |> success(!st.e.blk_bf16, "its halves are f16: eight-bit quants times a half scale")
+        var inscope f32 <- stage_audio_tower(path_join(models_dir(), "voxtral-mini-mmproj-f32.gguf"))
+        t |> success(empty(f32.wblob), "an f32 file bakes none: its GEMMs are no halfword's")
+    }
+    t |> run("the Qwen2.5-Omni mmproj's audio side loads as the whisper-class tower beside its vision tensors") @(t : T?) {
+        with_dasllama_jobque() {
+            tower_arm_cell(t, "mmproj-Qwen2.5-Omni-3B-f16.gguf", "qwen2a", 2048l, 750l)
+        }
+    }
 }
 
 // The pre-encoded audio rows on a PLAIN chat (no tower): the E2B family hears through this seam,
@@ -223,6 +326,11 @@ def test_audio_rows_need_an_audio_arm(t : T?) {
                 tripped = true
             }
             t |> success(tripped, "no audio arm: the rows are refused")
+            // an encoder whose span takes no marker (ultravox) owes the template none: the same rows queue
+            var bare_rows : array<float>
+            bare_rows |> resize(int(m.config.dim) * 2)
+            add_user_audio_rows(m, chat, bare_rows, 2l, true)
+            t |> equal(chat.n_audio_rows, 2l, "a bare span's rows queue on a template with no audio marker")
             delete chat
         }
     }
diff --git a/modules/dasLLAMA/tests/test_chat.das b/modules/dasLLAMA/tests/test_chat.das
index 6c8d66418f..b279e3b341 100644
--- a/modules/dasLLAMA/tests/test_chat.das
+++ b/modules/dasLLAMA/tests/test_chat.das
@@ -11,6 +11,7 @@ def private allow_cpu_prefill_intent() {
     allow_cpu_prefill()   // render/eval-seam test, CPU by design: on a Metal build the prefill guard panics otherwise
 }
 require dasllama/dasllama_tokenizer
+require dasllama/dasllama_blocks   // embed_text_rows: the media body cell builds rows from the prompt's own tokens
 require dasllama/dasllama_bpe
 require daslib/jobque_boost
 require daslib/fio
@@ -176,10 +177,13 @@ def test_chat_llama3(t : T?) {
         let sh = special_id(raw, "<|start_header_id|>")
         let eh = special_id(raw, "<|end_header_id|>")
         let eot = special_id(raw, "<|eot_id|>")
-        // old llama3_chat.das: BOS, header(system), "\n\n{sys}", eot, header(user), "\n\n{usr}", eot, header(assistant), "\n\n"
+        // the model's own template: every system turn opens with its knowledge-cutoff line and a date line, the
+        // caller's system text after them - and a conversation with no system message still carries the two lines
+        set_chat_date("26 Jul 2024")
+        let header = "Cutting Knowledge Date: December 2023\nToday Date: 26 Jul 2024\n\n"
         var want <- [raw.bos_id, sh]
         want |> push_from(bpe_encode(raw, "system")); want |> push(eh)
-        want |> push_from(bpe_encode(raw, "\n\n{SYS}"))
+        want |> push_from(bpe_encode(raw, "\n\n{header}{SYS}"))
         want |> push(eot)
         want |> push(sh); want |> push_from(bpe_encode(raw, "user")); want |> push(eh)
         want |> push_from(bpe_encode(raw, "\n\n{USR}"))
@@ -187,6 +191,13 @@ def test_chat_llama3(t : T?) {
         want |> push(sh); want |> push_from(bpe_encode(raw, "assistant")); want |> push(eh)
         want |> push_from(bpe_encode(raw, "\n\n"))
         t |> success(ids_equal(engine_prefill(m, SYS, USR), want), "llama3 header prefill token-for-token")
+        var inscope bare <- engine_prefill(m, "", USR)
+        var inscope lead <- bpe_encode(raw, "\n\n{header}")
+        t |> success(length(bare) > 4 + length(lead) && ids_equal([for (k in range(length(lead))); bare[4 + k]], lead),
+            "with no system message the turn still states the cutoff and the date")
+        set_chat_date("")
+        var inscope today <- engine_prefill(m, "", USR)
+        t |> success(!ids_equal(today, bare), "unpinned, the date is the day the turn renders")
         delete raw
         delete m
     }
@@ -291,8 +302,10 @@ def test_chat_tools_hermes(t : T?) {   // nolint:STYLE038 — flat expected-toke
         let tco = special_id(m, "<tool_call>")
         let tcc = special_id(m, "</tool_call>")
 
-        // no system, no tools: the replay shape alone. The assistant called get_weather...
+        // no system, no tools: the replay shape alone - the conversation opens with the system turn the model's own
+        // template states for one that carries none. The assistant called get_weather...
         var c = create_chat_renderer(m, "", 8l)
+        t |> equal(c.tmpl.default_system, "You are Qwen, created by Alibaba Cloud. You are a helpful assistant.", "the template's default system text, read off its escaped string literal")
         add_user(c, USR)
         var toks : array<int64>
         let call = "\{\"name\": \"get_weather\", \"arguments\": \{\"city\": \"Paris\"}}"
@@ -301,6 +314,10 @@ def test_chat_tools_hermes(t : T?) {   // nolint:STYLE038 — flat expected-toke
         render_assistant_calls(m, c, "", calls, toks)
         var want : array<int64>
         want |> push(ims)
+        want |> push_from(bpe_encode(raw, "system\n{c.tmpl.default_system}"))
+        want |> push(ime)
+        want |> push_from(bpe_encode(raw, "\n"))
+        want |> push(ims)
         want |> push_from(bpe_encode(raw, "user\n{USR}"))
         want |> push(ime)
         want |> push_from(bpe_encode(raw, "\n"))
@@ -439,9 +456,83 @@ def test_chat_gemma4_instruct_text_turn(t : T?) {
     }
 }
 
+//! the last row's logits of `toks` prefilled with rows [lo, hi) as embedding rows: one fused body, or text / rows / text as three calls
+def private e_series_body_logits(m : Model; toks : array<int64>; lo, hi : int64; fused, with_ids : bool) : array<float> {
+    var head <- [for (k in range64(lo)); toks[k]]
+    var mid <- [for (k in range64(lo, hi)); toks[k]]
+    var tail <- [for (k in range64(hi, long_length(toks))); toks[k]]
+    var rows : array<float>
+    rows |> resize((hi - lo) * m.config.dim)
+    embed_text_rows(m, mid, rows, 0l)
+    var s <- create_session(m)
+    if (fused) {
+        var body : array<float>
+        media_body_rows(m, s, head, rows, hi - lo, m.config.dim, tail, body)
+        if (!with_ids) {
+            s.embd_ids |> clear()
+        }
+        eval_embd_body(m, s, body, long_length(toks), 0l, 0l, int2(0))
+        delete body
+    } else {
+        eval(m, s, head)
+        eval_embd(m, s, rows, hi - lo)
+        eval(m, s, tail)
+    }
+    var out := s.logits
+    delete s
+    delete head
+    delete mid
+    delete tail
+    delete rows
+    return <- out
+}
+
+//! one side's top predicted token beside a logits compare, its id and its piece
+def private log_top_token(m : Model; side : string; logits : array<float>) {
+    let top = argmax_of(logits)
+    to_log(LOG_INFO, "E-series media body, {side}: top token {top} '{piece_(m, top)}'\n")
+}
+
+let private E_BODY_NEAR = 0.25  //! of the logits' peak: one body against three calls differs by call shape alone - 0.11 here, and the same tokens as ids read 0.14 apart in one call and in three
+let private E_BODY_FAR = 1.0     //! of the peak: text rows under the padding token's per-layer input are another prompt - 1.9 here
+
+[test]
+def test_gemma4_e_media_body(t : T?) {
+    t |> run("an E-series media body gives its text rows their own tokens' per-layer input: one call == text / rows / text (needs gemma-4-E2B)") @(t : T?) {
+        let path = path_join(models_dir(), "gemma-4-E2B-it-Q4_K_M.gguf")
+        if (!model_available(t, path)) {
+            return
+        }
+        var m <- load_capped(path)
+        allow_cpu_prefill()
+        with_dasllama_jobque() {
+            var toks <- encode(m, "The quick brown fox jumps over the lazy dog while the little robot watches from a small hill near the old village bakery", true, false)
+            let np = long_length(toks)
+            t |> success(np > 16l, "the prompt holds a head, a span and a tail ({np} tokens)")
+            var split <- e_series_body_logits(m, toks, 5l, 11l, false, true)
+            var fused <- e_series_body_logits(m, toks, 5l, 11l, true, true)
+            var padded <- e_series_body_logits(m, toks, 5l, 11l, true, false)
+            let peak = logits_maxabs(split)
+            let near = logits_maxdiff(fused, split)
+            let far = logits_maxdiff(padded, split)
+            to_log(LOG_INFO, "E-series media body: one call {near} from three, the padding-id body {far}, at a {peak} peak\n")
+            log_top_token(m, "three calls", split)
+            log_top_token(m, "one call", fused)
+            log_top_token(m, "the padding-id body", padded)
+            t |> success(near < E_BODY_NEAR * peak, "one call reads as three ({near} at a {peak} peak)")
+            t |> success(far > E_BODY_FAR * peak, "the ids are load-bearing: a body without them reads another prompt ({far} at a {peak} peak)")
+            delete split
+            delete fused
+            delete padded
+            delete toks
+        }
+        delete m
+    }
+}
+
 [test]
 def test_chat_gemma4_thinking(t : T?) {   // nolint:STYLE038 — flat expected-token stream, one push per run
-    t |> run("default = thinking; instruct opt-out = closed empty thought (needs gemma-4-E2B)") @(t : T?) {
+    t |> run("default = thinking; instruct opt-out = the template's bare model turn (needs gemma-4-E2B)") @(t : T?) {
         let path = path_join(models_dir(), "gemma-4-E2B-it-Q4_K_M.gguf")
         if (!stat(path).is_valid) {
             t |> skip("{path} not present")
@@ -458,8 +549,7 @@ def test_chat_gemma4_thinking(t : T?) {   // nolint:STYLE038 — flat expected-t
 
         var c = create_chat_renderer(m, "", 8l)
         t |> success(c.enable_thinking, "gemma-4 defaults to thinking on (thinking-trained family)")
-        // instruct opt-out: the closed empty thought prefill — the exact pre-thinking-arc token
-        // stream, pinned so the assistant_open restructure changes nothing
+        // instruct opt-out: the E-series template opens the model turn bare
         set_thinking(c, false)
         // instruct mode stops at a stray channel marker; thinking-ON must NOT (they frame the thought)
         let base_stops = length(c.stop_ids)
@@ -480,9 +570,6 @@ def test_chat_gemma4_thinking(t : T?) {   // nolint:STYLE038 — flat expected-t
         want |> push_from(encode(m, "\n", false, false))
         want |> push(trn)
         want |> push_from(encode(m, "model\n", false, false))
-        want |> push(cho)
-        want |> push_from(encode(m, "thought\n", false, false))
-        want |> push(chc)
         t |> success(ids_equal(got, want), "default prefill token-for-token (instruct shape)")
         delete c
 
@@ -538,7 +625,7 @@ def test_chat_gemma4_thinking(t : T?) {   // nolint:STYLE038 — flat expected-t
         add_user(c5, "and again?")
         let got5 <- render_turn(m, c5)
         t |> success(find_index(got5, thk) < 0, "no late gate materializes")
-        t |> equal(got5[length(got5) - 1], chc, "the opener keeps the closed empty thought")
+        t |> success(find_index(got5, chc) < 0, "the opener is the E-series template's bare model turn: no closed thought ahead of the answer")
         var eff5 <- effective_stop_ids(c5)
         t |> success(find_index(eff5, chc) >= 0, "the channel-marker stops stay armed (thinking never armed)")
         delete eff5
@@ -638,8 +725,6 @@ def test_chat_gemma4_tool_wire(t : T?) {   // nolint:STYLE038 — flat expected-
         var m <- load_capped(path)
         let trn = special_id(m, "<|turn>")
         let trc = special_id(m, "<turn|>")
-        let cho = special_id(m, "<|channel>")
-        let chc = special_id(m, "<channel|>")
         let tlo = special_id(m, "<|tool>")
         let tlc = special_id(m, "<tool|>")
         let tco = special_id(m, "<|tool_call>")
@@ -690,9 +775,6 @@ def test_chat_gemma4_tool_wire(t : T?) {   // nolint:STYLE038 — flat expected-
         want |> push_from(encode(m, "\n", false, false))
         want |> push(trn)
         want |> push_from(encode(m, "model\n", false, false))
-        want |> push(cho)
-        want |> push_from(encode(m, "thought\n", false, false))
-        want |> push(chc)
         t |> success(ids_equal(got, want), "defs turn token-for-token")
         delete c
 
@@ -710,9 +792,6 @@ def test_chat_gemma4_tool_wire(t : T?) {   // nolint:STYLE038 — flat expected-
         want2 |> push_from(encode(m, "\n", false, false))
         want2 |> push(trn)
         want2 |> push_from(encode(m, "model\n", false, false))
-        want2 |> push(cho)
-        want2 |> push_from(encode(m, "thought\n", false, false))
-        want2 |> push(chc)
         want2 |> push(tco)
         want2 |> push_from(encode(m, "call:get_weather\{city:", false, false))
         want2 |> push(q)
@@ -747,8 +826,6 @@ def test_chat_gemma4_tool_wire(t : T?) {   // nolint:STYLE038 — flat expected-
         var m <- load_capped(path)
         let trn = special_id(m, "<|turn>")
         let trc = special_id(m, "<turn|>")
-        let cho = special_id(m, "<|channel>")
-        let chc = special_id(m, "<channel|>")
         let tro = special_id(m, "<|tool_response>")
         let trr = special_id(m, "<tool_response|>")
 
@@ -781,9 +858,6 @@ def test_chat_gemma4_tool_wire(t : T?) {   // nolint:STYLE038 — flat expected-
         want |> push_from(encode(m, "\n", false, false))
         want |> push(trn)
         want |> push_from(encode(m, "model\n", false, false))
-        want |> push(cho)
-        want |> push_from(encode(m, "thought\n", false, false))
-        want |> push(chc)
         t |> success(ids_equal(got, want), "displaced results + close + user turn token-for-token")
         delete c
 
@@ -805,9 +879,6 @@ def test_chat_gemma4_tool_wire(t : T?) {   // nolint:STYLE038 — flat expected-
         want2 |> push_from(encode(m, "\n", false, false))
         want2 |> push(trn)
         want2 |> push_from(encode(m, "model\n", false, false))
-        want2 |> push(cho)
-        want2 |> push_from(encode(m, "thought\n", false, false))
-        want2 |> push(chc)
         t |> success(ids_equal(got2, want2), "the leaked open turn closes before the user turn")
         delete c2
         delete m
@@ -996,6 +1067,212 @@ def private detok(m : Model; ids : array<int64>) : string {
     return replace(raw, "\n", "\\n")
 }
 
+[test]
+def test_chat_inline_span(t : T?) {
+    t |> run("an inline span renders the turn the splice pair renders, its position ids where the rows go - in a replayed turn too") @(t : T?) {
+        let path = path_join(models_dir(), "voxtral-mini-3b-q8_0.gguf")
+        if (!model_available(t, path)) {
+            return
+        }
+        var m <- load_capped(path)
+        let key = 0x1234abcdul
+        for (before in [0, 4, length(USR)]) {
+            var c <- create_chat_renderer_(m)
+            add_user(c, USR)
+            c.n_audio_rows = 3l
+            var inscope head : array<int64>
+            var inscope tail : array<int64>
+            render_turn_audio_(m, c, head, tail, before)
+            var inscope ids <- [for (r in range64(3l)); media_position_id(key, r)]
+            var inscope want := head
+            want |> push_from(ids, tail)
+            var ci <- create_chat_renderer_(m)
+            add_user(ci, USR)
+            add_user_span_(m, ci, key, 3l, before, false, false)
+            var inscope got <- render_turn_(m, ci)
+            t |> success(ids_equal(got, want), "{before}: the inline turn is head + ids + tail ({length(got)} vs {length(want)} positions)")
+            // the same turn replayed as history: the span stays in the transcript, the reply and the close after it
+            var inscope hist : array<int64>
+            render_assistant_(m, ci, "ok", hist)
+            t |> success(length(hist) > length(head) + 3 && ids_equal([for (k in range(length(head) + 3)); hist[k]], [for (k in range(length(head) + 3)); want[k]]),
+                "{before}: a replayed turn keeps its span")
+            t |> success(empty(ci.pending_spans), "{before}: the consumed turn leaves no span queued")
+            delete ci
+            delete c
+        }
+        t |> success(is_media_position(media_position_id(key, 0l)) && media_position_id(key, 0l) != media_position_id(key, 1l)
+            && media_position_id(key, 0l) != media_position_id(key + 1ul, 0l), "a position id is no token id, and differs by row and by key")
+        delete m
+    }
+}
+
+//! whether `add_user_span_` refuses the span by panic, on a fresh chat that already holds the `queued` spans' text offsets
+def private span_refused(m : Model; queued : array<int>; n_rows : int64; text_before : int; is_image, bare : bool) : bool {
+    var c <- create_chat_renderer_(m)
+    add_user(c, USR)
+    for (at in queued) {
+        add_user_span_(m, c, 0x77ul, 1l, at, false, true)
+    }
+    var refused = false
+    try {
+        add_user_span_(m, c, 0x77ul, n_rows, text_before, is_image, bare)
+    } recover {
+        refused = true
+    }
+    delete c
+    return refused
+}
+
+// A template with no media markers takes a span only where the encoder's rows need none (a bare audio span); every span
+// has rows, and spans queue in text order.
+[test]
+def test_chat_span_refusals(t : T?) {
+    t |> run("add_user_span_ refuses a span the template cannot mark, an empty span, and one out of text order") @(t : T?) {
+        let path = path_join(models_dir(), "SmolLM2-135M-Instruct-Q8_0.gguf")
+        if (!model_available(t, path)) {
+            return
+        }
+        var m <- load_capped(path)
+        var none : array<int>
+        t |> success(!span_refused(m, none, 2l, 4, false, true), "a bare audio span needs no markers (the control)")
+        t |> success(span_refused(m, none, 0l, 4, false, true), "a span of no rows panics")
+        t |> success(span_refused(m, none, -1l, 4, false, true), "a span of negative rows panics")
+        t |> success(span_refused(m, none, 2l, 4, true, false), "an image span on a template with no image markers panics")
+        t |> success(span_refused(m, none, 2l, 4, false, false), "a marked audio span on a template with no audio markers panics")
+        t |> success(!span_refused(m, [4], 2l, 4, false, true), "a span at the offset of the one before it queues")
+        t |> success(span_refused(m, [4], 2l, 2, false, true), "a span ahead of the one queued before it panics")
+        delete none
+        delete m
+    }
+}
+
+// A gemma-4 template's non-thinking generation prompt is read off the model's own template: the larger models close
+// an empty thought channel after the model turn's opener, the E-series opens the turn bare.
+[test]
+def test_gemma4_instruct_opener(t : T?) {
+    t |> run("the non-thinking opener follows the template: a closed thought where it writes one, bare where it does not") @(t : T?) {
+        let cases = [
+            (name = "the 12B form", parts = 5,
+             src = "\{\{- '<|turn>model\\n' -}}\{%- if not enable_thinking -%}\{\{- '<|channel>thought\\n<channel|>' -}}\{%- endif -%}"),
+            (name = "the E-series form", parts = 2,
+             src = "\{\{- '<|turn>model\\n' -}}\{%- elif enable_thinking -%}\{\{- '<|channel>thought\\n' -}}\{%- endif -%}")
+        ]
+        for (c in cases) {
+            var m = Model()
+            m.chat_template_str = c.src
+            var inscope tmpl <- chat_template(m)
+            t |> equal(length(tmpl.assistant_open.parts), c.parts, c.name)
+            t |> equal(length(tmpl.assistant_open_think.parts), 2, "{c.name}: the thinking opener is the bare model turn")
+            delete m
+        }
+    }
+}
+
+// A Llama-3.1+ template's system header is read off the template: the cutoff line, and the date line's date where the
+// template fixes one; a template with a clock states the day, and one with no header (Llama-3.0) states nothing.
+[test]
+def test_llama_system_header(t : T?) {
+    t |> run("the dated system header follows the template") @(t : T?) {
+        let head = "\{\{- \"<|start_header_id|>system<|end_header_id|>\\n\\n\" }}\{\{- \"Cutting Knowledge Date: December 2023\\n\" }}\{\{- \"Today Date: \" + date_string + \"\\n\\n\" }}"
+        let cases = [
+            (name = "a fixed date (3.1)", dated = true, date = "26 Jul 2024",
+             src = "\{%- set date_string = \"26 Jul 2024\" %}{head}"),
+            (name = "a clock (3.2)", dated = true, date = "",
+             src = "\{%- if strftime_now is defined %}\{%- set date_string = strftime_now(\"%d %b %Y\") %}\{%- else %}\{%- set date_string = \"26 Jul 2024\" %}\{%- endif %}{head}"),
+            (name = "no header (3.0)", dated = false, date = "",
+             src = "\{\{- '<|start_header_id|>' + message['role'] + '<|end_header_id|>\\n\\n' }}")
+        ]
+        for (c in cases) {
+            var m = Model()
+            m.chat_template_str = c.src
+            var inscope tmpl <- chat_template(m)
+            t |> equal(tmpl.system_dated, c.dated, c.name)
+            t |> equal(tmpl.system_date, c.date, "{c.name}: the date the template fixes")
+            t |> equal(tmpl.system_lead, c.dated ? "Cutting Knowledge Date: December 2023\n" : "", "{c.name}: the cutoff line")
+            delete m
+        }
+    }
+    t |> run("the rendered header: a tool-carrying turn opens with the environment line, and a pinned date wins over the template's") @(t : T?) {
+        let path = path_join(models_dir(), "Llama-3.2-1B-Instruct-Q8_0.gguf")
+        if (!model_available(t, path)) {
+            return
+        }
+        var m <- load_capped(path)
+        set_chat_date("")
+        let plain = system_header_text(m, "01 Jan 2030", false)
+        let tooled = system_header_text(m, "01 Jan 2030", true)
+        set_chat_date("26 Jul 2024")
+        let pinned = system_header_text(m, "01 Jan 2030", false)
+        set_chat_date("")
+        to_log(LOG_INFO, "llama header, the template's date: '{plain}'\nwith a tool: '{tooled}'\nthe date pinned: '{pinned}'\n")
+        t |> success(find(plain, "\\n\\nCutting Knowledge Date: December 2023\\nToday Date: 01 Jan 2030\\n\\n") >= 0, "unpinned, the turn states the date the template fixes")
+        t |> success(find(plain, "Environment: ipython") < 0, "a turn with no tools states no environment line")
+        t |> success(find(tooled, "\\n\\nEnvironment: ipython\\nCutting Knowledge Date: December 2023\\nToday Date: 01 Jan 2030\\n\\n") >= 0, "a tool-carrying turn opens with the environment line, ahead of the cutoff")
+        t |> success(find(pinned, "Today Date: 26 Jul 2024\\n") >= 0 && find(pinned, "2030") < 0, "a pinned date wins over the template's own")
+        delete m
+    }
+}
+
+//! the first turn's detokenized render on a Llama-3.2 chat whose template fixes `date` (as 3.1's does), with a tool or none
+def private system_header_text(m : Model; date : string; with_tool : bool) : string {
+    var c <- create_chat_renderer_(m)
+    c.tmpl.system_date = date
+    if (with_tool) {
+        var tools <- ["\{\"type\": \"function\", \"function\": \{\"name\": \"get_time\", \"parameters\": \{\"type\": \"object\", \"properties\": \{}}}}"]
+        set_tools_(c, tools)
+        delete tools
+    }
+    add_user(c, USR)
+    var inscope toks <- render_turn_(m, c)
+    delete c
+    return detok(m, toks)
+}
+
+// The system text a ChatML template states for a conversation with no system message, read off the three shapes the
+// stocked templates take; a span that carries an expression is the caller's own system turn and yields none.
+[test]
+def test_chatml_default_system(t : T?) {
+    t |> run("the default system text is the template's literal, never one of its expressions") @(t : T?) {
+        let cases = [
+            (name = "template text (Qwen2.5-Omni)", want = "You are a helpful assistant.",
+             src = "\{% if loop.first and message['role'] != 'system' %}<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n\{% endif %}<|im_start|>\{\{ message['role'] }}"),
+            (name = "a string literal (Qwen2.5)", want = "You are Qwen, created by Alibaba Cloud. You are a helpful assistant.",
+             src = "\{\{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\{%- else %}\{\{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}"),
+            (name = "an expression alone (Qwen3.5)", want = "",
+             src = "\{\{- '<|im_start|>system\\n' }}\{\{- \"# Tools\" }}<|im_end|>\{\{- '<|im_start|>system\\n' + content + '<|im_end|>\\n' }}"),
+            (name = "no system literal at all", want = "",
+             src = "\{\{- '<|im_start|>' + message.role + '\\n' + content + '<|im_end|>' }}")
+        ]
+        for (c in cases) {
+            var m = Model()
+            m.chat_template_str = c.src
+            var inscope tmpl <- chat_template(m)
+            t |> equal(tmpl.default_system, c.want, c.name)
+            delete m
+        }
+    }
+}
+
+//! one audio turn rendered with `before` bytes of the user text ahead of the splice: the head closes with the opening marker
+//! and carries exactly that text, the tail the rest
+def private audio_splice_cell(t : T?; m : Model; before : int) {
+    var c <- create_chat_renderer_(m)
+    add_user(c, USR)
+    c.n_audio_rows = 3l
+    var inscope head : array<int64>
+    var inscope tail : array<int64>
+    render_prompt_audio(m, c, head, tail, before)
+    let h = detok(m, head)
+    let tl = detok(m, tail)
+    let lead = slice(USR, 0, max(before, 4))
+    let rest = slice(USR, before)
+    to_log(LOG_INFO, "voxtral audio at {before}: '{h}' [audio x3] '{tl}'\n")
+    t |> equal(head[length(head) - 1], special_id(m, "[BEGIN_AUDIO]"), "{before}: the head still closes with the opening marker")
+    t |> success(before == 0 ? find(h, lead) < 0 : find(h, lead) >= 0, "{before}: the head carries exactly the text ahead of the audio")
+    t |> success(before == length(USR) ? find(tl, "time") < 0 : find(tl, rest) >= 0, "{before}: the tail carries the text after it")
+    delete c
+}
+
 // The chat-audio marker gate: render_prompt_audio must bracket the soft-token splice in the
 // family's audio markers — the render-side half of the chat-audio rail (encoder numerics are
 // test_audio's; nothing else pins these template tags against a real vocab).
@@ -1021,6 +1298,17 @@ def test_chat_audio_markers(t : T?) {
         delete c
         delete m
     }
+    t |> run("the audio splices where the message put it: ahead of the text, after it, inside it") @(t : T?) {
+        let path = path_join(models_dir(), "voxtral-mini-3b-q8_0.gguf")
+        if (!model_available(t, path)) {
+            return
+        }
+        var m <- load_capped(path)
+        for (before in [0, 4, length(USR)]) {
+            audio_splice_cell(t, m, before)
+        }
+        delete m
+    }
     t |> run("qwen2audio audio turn is bracketed by <|audio_bos|>/<|audio_eos|>") @(t : T?) {
         let path = path_join(models_dir(), "qwen2audio-7b-q8_0.gguf")
         if (!model_available(t, path)) {   // 7.7 GB — runs under DASLLAMA_PARITY_FULL=1
diff --git a/modules/dasLLAMA/tests/test_gemma3v.das b/modules/dasLLAMA/tests/test_gemma3v.das
index 4c0689130b..a561eafb41 100644
--- a/modules/dasLLAMA/tests/test_gemma3v.das
+++ b/modules/dasLLAMA/tests/test_gemma3v.das
@@ -176,6 +176,56 @@ def test_gemma3v_tier1_gpu(t : T?) {
     }
 }
 
+// The projector tail on the device against the CPU tail over the SAME device block rows (the tail lever off): the soft
+// tokens within 1e-3 rel-l2, the tail counter up by the device leg alone, another canvas outside the bar (the control).
+[test]
+def test_gemma3v_tail_gpu(t : T?) {
+    t |> run("the post-norm, grid pool, soft norm and projection ride the device behind the blocks") @(tt : T?) {
+        static_if (typeinfo builtin_module_exists(das_metal)) {
+            let mm = path_join(models_dir(), "mmproj-gemma-3-4b-it-F16.gguf")
+            return if (!jit_model_available(tt, mm))
+            var tw <- mint_tower(mm, false)
+            var st = Gemma3vState()
+            let px = int(tw.image_px)
+            var inscope cb <- make_planes("cb", px, px)
+            var inscope green <- make_planes("green", px, px)
+            let tower_was = metal_tower_knob()
+            let tail_was = metal_tower_tail_knob()
+            set_metal_tower(true)
+            with_dasllama_jobque_() {
+                var inscope cpu_tail : array<float>
+                var inscope dev_tail : array<float>
+                var inscope other : array<float>
+                set_metal_tower_tail(false)
+                let e0 = metal_tower_stats().encodes
+                let t0 = metal_tower_tail_encodes()
+                let n = gemma3v_encode(tw, st, cb, tw.image_px, tw.image_px, cpu_tail)
+                tt |> equal(metal_tower_stats().encodes - e0, 1l, "lever off: the blocks still ride the device")
+                tt |> equal(metal_tower_tail_encodes() - t0, 0l, "lever off: the tail stays on the CPU")
+                set_metal_tower_tail(true)
+                tt |> equal(gemma3v_encode(tw, st, cb, tw.image_px, tw.image_px, dev_tail), n, "the same row count")
+                tt |> equal(metal_tower_tail_encodes() - t0, 1l, "lever on: the tail rides the device behind the blocks")
+                gemma3v_encode(tw, st, green, tw.image_px, tw.image_px, other)
+                var inscope a <- copy_span(cpu_tail, 0l, n * tw.proj_dim)
+                var inscope b <- copy_span(dev_tail, 0l, n * tw.proj_dim)
+                var inscope c <- copy_span(other, 0l, n * tw.proj_dim)
+                var got = TowerParityStats()
+                var ctl = TowerParityStats()
+                if (tower_parity_stats(tt, "gemma3v tail", a, b, got) && tower_parity_stats(tt, "gemma3v tail control", a, c, ctl)) {
+                    tt |> success(got.rel_l2 <= 1e-3lf, "device tail vs CPU tail rel_l2 {got.rel_l2}")
+                    tt |> success(ctl.rel_l2 > 1e-3lf, "another canvas lands outside the bar (rel_l2 {ctl.rel_l2}) - the control")
+                }
+            }
+            set_metal_tower_tail(tail_was)
+            set_metal_tower(tower_was)
+            delete st
+            delete tw
+        } else {
+            feint("das_metal is not built on this platform - the device tail is Apple-only\n")
+        }
+    }
+}
+
 // The q8 serving lane (the CPU default): the same dumps on its own scale-relative bar.
 [test]
 def test_gemma3v_tier1_q8(t : T?) {
diff --git a/modules/dasLLAMA/tests/test_kv_paged.das b/modules/dasLLAMA/tests/test_kv_paged.das
index 6156859d5b..d9317b15ce 100644
--- a/modules/dasLLAMA/tests/test_kv_paged.das
+++ b/modules/dasLLAMA/tests/test_kv_paged.das
@@ -76,6 +76,26 @@ def test_kv_pool_alloc_release(t : T?) {
         t |> equal(pool.capacity_groups, 8l)
         delete pool
     }
+    t |> run("growth inside a reserve moves no blob and keeps the rows written; past it the pool still grows") @(t : T?) {
+        let c = mk_config(2l, 4l, 2l, 16l, 32l)
+        var pool <- create_kv_pool_(c, 4l, KVDtype.f32, KVDtype.f32)
+        kv_pool_reserve(pool, 32l)
+        t |> equal(long_capacity(pool.kblobs[0]), 8l * 4l * pool.krow_bytes[0])
+        t |> equal(pool.capacity_groups, 0l)
+        kv_pool_alloc_group(pool)
+        pool.kblobs[0][0] = 0x5au8
+        let home = unsafe(addr(pool.kblobs[0][0]))
+        for (_i in range(7)) {
+            kv_pool_alloc_group(pool)
+        }
+        t |> equal(pool.capacity_groups, 8l)
+        t |> equal(home, unsafe(addr(pool.kblobs[0][0])))
+        t |> equal(pool.kblobs[0][0], 0x5au8)
+        t |> equal(8, kv_pool_alloc_group(pool))
+        t |> equal(pool.capacity_groups, 16l)
+        t |> equal(pool.kblobs[0][0], 0x5au8)
+        delete pool
+    }
 }
 
 [test]
diff --git a/modules/dasLLAMA/tests/test_kv_prefix.das b/modules/dasLLAMA/tests/test_kv_prefix.das
index 79d28fdcdf..a47dea4d66 100644
--- a/modules/dasLLAMA/tests/test_kv_prefix.das
+++ b/modules/dasLLAMA/tests/test_kv_prefix.das
@@ -44,6 +44,7 @@ def test_prefix_accounting(t : T?) {
         t |> equal(1, pool.refcnt[g1])
         // np == 8 -> pages_max = (8-1)/4 = 1 whole page shared, then three rows of the second as a COPY: the cap leaves one token to eval for logits
         var w <- make_run_state_paged(c, pool)
+        t |> equal(7l, prefix_match_len_(cache, pool, toks), "the probe reads what the attach will attach")
         t |> equal(7l, prefix_attach_(cache, pool, w, toks))
         t |> equal(7l, w.n_past)
         t |> equal(2, length(w.block_table))
@@ -55,11 +56,13 @@ def test_prefix_accounting(t : T?) {
         // a longer prompt with the same 8-token prefix attaches BOTH pages
         var toks12 <- [for (i in range64(12l)); i < 8l ? 100l + i : 900l + i]
         var w2 <- make_run_state_paged(c, pool)
+        t |> equal(8l, prefix_match_len_(cache, pool, toks12), "the probe reads what the attach will attach")
         t |> equal(8l, prefix_attach_(cache, pool, w2, toks12))
         t |> equal(3, pool.refcnt[g0])
         // divergence in page 0 -> no match, nothing attached
         var other <- [for (i in range64(8l)); 500l + i]
         var w3 <- make_run_state_paged(c, pool)
+        t |> equal(0l, prefix_match_len_(cache, pool, other), "the probe reads what the attach will attach")
         t |> equal(0l, prefix_attach_(cache, pool, w3, other))
         t |> equal(0, length(w3.block_table))
         t |> equal(0l, w3.n_past)
@@ -97,6 +100,7 @@ def test_prefix_lru_budget(t : T?) {
         t |> equal(2, pool.refcnt[s.block_table[1]])
         // page 0 is gone and the chain starts there -> attach misses at once
         var w <- make_run_state_paged(c, pool)
+        t |> equal(0l, prefix_match_len_(cache, pool, toks), "the probe reads what the attach will attach")
         t |> equal(0l, prefix_attach_(cache, pool, w, toks))
         release_kv_pages_(s)
         prefix_release_(cache, pool)
@@ -140,12 +144,14 @@ def test_prefix_tail_edges(t : T?) {
         // one whole hit, then two rows of A1 - of the two pages past A0, the one the prompt shares rows with
         var two <- [100l, 101l, 102l, 103l, 104l, 105l, 999l, 998l]
         var w1 <- make_run_state_paged(c, pool)
+        t |> equal(6l, prefix_match_len_(cache, pool, two), "the probe reads what the attach will attach")
         t |> equal(6l, prefix_attach_(cache, pool, w1, two), "A1 follows A0 and the prompt shares its two rows")
         t |> equal(1l, cache.n_hit_partial)
         t |> success(w1.block_table[1] != ga1 && w1.block_table[1] != gb1, "the partly shared page is a copy")
         // the same hit, then three rows of B1: the second donation's page past A0 serves a prompt that follows it
         var like_b <- [100l, 101l, 102l, 103l, 704l, 705l, 706l, 999l, 998l]
         var w2 <- make_run_state_paged(c, pool)
+        t |> equal(7l, prefix_match_len_(cache, pool, like_b), "the probe reads what the attach will attach")
         t |> equal(7l, prefix_attach_(cache, pool, w2, like_b), "B1 follows A0 too, and the prompt shares three of its rows")
         t |> success(w2.block_table[1] != ga1 && w2.block_table[1] != gb1, "and its page is a copy as well")
         release_kv_pages_(w2)
@@ -212,6 +218,7 @@ def test_prefix_first_page_edges(t : T?) {
         t |> equal(2, length(cache.roots), "each donation's first page is a candidate")
         var like_a <- [100l, 101l, 102l, 900l, 901l]
         var w0 <- make_run_state_paged(c, pool)
+        t |> equal(3l, prefix_match_len_(cache, pool, like_a), "the probe reads what the attach will attach")
         t |> equal(3l, prefix_attach_(cache, pool, w0, like_a), "three rows of A's page beat two of B's")
         var chains <- prefix_chain_list_(cache)
         t |> equal(1l, [for (ch in chains); ch.hits] |> sum(), "the chain whose first page was copied is credited the hit")
@@ -219,12 +226,15 @@ def test_prefix_first_page_edges(t : T?) {
         t |> success(length(w0.block_table) == 1 && w0.block_table[0] != ga && w0.block_table[0] != gb, "the page is a copy")
         var like_b <- [100l, 101l, 502l, 900l, 901l]
         var w1 <- make_run_state_paged(c, pool)
+        t |> equal(3l, prefix_match_len_(cache, pool, like_b), "the probe reads what the attach will attach")
         t |> equal(3l, prefix_attach_(cache, pool, w1, like_b), "three leading rows of B's whole page")
         var same_a <- [100l, 101l, 102l]
         var w2 <- make_run_state_paged(c, pool)
+        t |> equal(2l, prefix_match_len_(cache, pool, same_a), "the probe reads what the attach will attach")
         t |> equal(2l, prefix_attach_(cache, pool, w2, same_a), "the same prompt again stops a token short, so the tail eval lands logits")
         var none <- [777l, 100l, 101l]
         var w3 <- make_run_state_paged(c, pool)
+        t |> equal(0l, prefix_match_len_(cache, pool, none), "the probe reads what the attach will attach")
         t |> equal(0l, prefix_attach_(cache, pool, w3, none))
         t |> success(empty(w3.block_table), "a prompt sharing no first row takes no page")
         t |> equal(3l, cache.n_hit_partial)
@@ -278,6 +288,7 @@ def test_prefix_verify_tokens(t : T?) {
             e.tokens[0] = 424242l
         }
         var w <- make_run_state_paged(c, pool)
+        t |> equal(0l, prefix_match_len_(cache, pool, toks), "the probe reads what the attach will attach")
         t |> equal(0l, prefix_attach_(cache, pool, w, toks))
         t |> equal(0, length(w.block_table))
         release_kv_pages_(s)
@@ -333,6 +344,7 @@ def test_prefix_checkpoint_accounting(t : T?) {
         prefix_insert_(cache, pool, s, toks)
         t |> equal(1, length(cache.states), "the same tokens leave no second checkpoint")
         var w <- mk_recurrent(c, pool, 0l)
+        t |> equal(0l, prefix_match_len_(cache, pool, toks), "a recurrent cache attaches at checkpoints: the probe answers nothing held")
         t |> equal(6l, prefix_attach_(cache, pool, w, toks), "a prompt past the checkpoint attaches all of it")
         t |> equal(6l, w.n_past)
         t |> equal(6l, w.dn_pos, "the recurrent state stands at the checkpoint")
@@ -345,8 +357,10 @@ def test_prefix_checkpoint_accounting(t : T?) {
         t |> equal(1, pool.refcnt[w.block_table[1]])
         var same <- [for (i in range64(6l)); 100l + i]
         var w2 <- mk_recurrent(c, pool, 0l)
+        t |> equal(0l, prefix_match_len_(cache, pool, same), "the probe reads what the attach will attach")
         t |> equal(0l, prefix_attach_(cache, pool, w2, same), "a prompt the checkpoint covers whole attaches nothing: its last token must be evaled")
         var other <- [for (i in range64(9l)); i < 5l ? 100l + i : 700l + i]
+        t |> equal(0l, prefix_match_len_(cache, pool, other), "the probe reads what the attach will attach")
         t |> equal(0l, prefix_attach_(cache, pool, w2, other), "a prompt leaving the checkpoint's tokens early attaches nothing: the state is at one position only")
         release_kv_pages_(s)
         release_kv_pages_(w)
@@ -375,6 +389,7 @@ def test_prefix_checkpoint_accounting(t : T?) {
         prefix_insert_(cache, pool, off, toks)
         t |> equal(1, length(cache.states))
         var w <- mk_recurrent(c, pool, 0l)
+        t |> equal(0l, prefix_match_len_(cache, pool, toks), "a recurrent cache attaches at checkpoints: the probe answers nothing held")
         t |> equal(8l, prefix_attach_(cache, pool, w, toks))
         t |> equal(off.block_table[0], w.block_table[0], "the first page is shared")
         t |> success(w.block_table[1] != off.block_table[1], "the page of row 7 is copied though it is whole: the draft head rewrites that row")
@@ -508,6 +523,7 @@ def test_prefix_checkpoint_side_state(t : T?) {
         var w <- mk_recurrent(c, pool, 0l)
         w.ple_prev <- [-1l, -1l]
         w.ple_conv_hist |> reserve_resize(6l)
+        t |> equal(0l, prefix_match_len_(cache, pool, toks), "a recurrent cache attaches at checkpoints: the probe answers nothing held")
         t |> equal(6l, prefix_attach_(cache, pool, w, toks))
         t |> success(w.ple_prev[0] == 7l && w.ple_prev[1] == 8l, "the attached session holds the checkpoint's last tokens ({w.ple_prev[0]}, {w.ple_prev[1]})")
         t |> success(w.ple_conv_hist[0] == 6000.0 && w.ple_conv_hist[5] == 6005.0, "and its conv history ({w.ple_conv_hist[0]} .. {w.ple_conv_hist[5]})")
@@ -591,6 +607,7 @@ def test_prefix_warm_equals_cold(t : T?) {   // nolint:STYLE038 — cold/warm/di
             release_kv_pages_(cold)
             // WARM: attach 2 pages ((21-1)/8) shared and four rows of the third copied, classic-eval only the last token
             var warm <- make_run_state_paged(c, pool)
+            t |> equal(20l, prefix_match_len_(cache, pool, prompt), "the probe reads what the attach will attach")
             t |> equal(20l, prefix_attach_(cache, pool, warm, prompt))
             t |> equal(g0, warm.block_table[0])   // the whole pages are SHARED, not copied
             t |> equal(g1, warm.block_table[1])
@@ -617,6 +634,7 @@ def test_prefix_warm_equals_cold(t : T?) {   // nolint:STYLE038 — cold/warm/di
             var cold2 <- make_run_state_paged(c, pool)
             eval_(tr, cold2, prompt2)
             var warm2 <- make_run_state_paged(c, pool)
+            t |> equal(16l, prefix_match_len_(cache, pool, prompt2), "the probe reads what the attach will attach")
             t |> equal(16l, prefix_attach_(cache, pool, warm2, prompt2))
             var tail2 <- [for (j in range64(16l, 24l)); prompt2[j]]
             eval_(tr, warm2, tail2)
diff --git a/modules/dasLLAMA/tests/test_metal_prefill_kernels.das b/modules/dasLLAMA/tests/test_metal_prefill_kernels.das
index 4dec17591d..2627f5fcc1 100644
--- a/modules/dasLLAMA/tests/test_metal_prefill_kernels.das
+++ b/modules/dasLLAMA/tests/test_metal_prefill_kernels.das
@@ -819,6 +819,177 @@ def private pk_xf_gate(t : T?; var dev, queue) {
     }
 }
 
+//! Canary's log and per-feature normalization, in place over the mel sums: log(sum + floor), the mean and the Bessel
+//! deviation over the valid frames in double, every valid frame normalized and the frames past them zero; rows past
+//! the mel keep their sentinel.
+def private cn_melnorm_gate(t : T?; var dev, queue) {
+    let tag = "cn_melnorm"
+    with_metal_cell(dev, queue) $(var mc : MetalCell) {
+        var err : string
+        let kd = kernel_of(@@enc_cn_melnorm)
+        var pso = mc |> keep_stamp(kd, err)
+        return if (!pso_ok(t, tag, pso, err))
+        let nmel = 70      // off the 64-thread group: the last group's guard runs
+        let nlen = 11
+        let valid = 7
+        let rows = 13      // two rows past the mel: untouched
+        let mfloor = 5.960464477539063e-08
+        var inscope x <- [for (i in range(rows * nmel)); 0.001 + float((i * 37) % 101) * 0.37]
+        var inscope want := x
+        for (j in range(nmel)) {
+            var sum = 0.0lf
+            for (i in range(valid)) {
+                sum += log(double(x[i * nmel + j]) + double(mfloor))
+            }
+            let mean = sum / double(valid)
+            var sq = 0.0lf
+            for (i in range(valid)) {
+                let dv = log(double(x[i * nmel + j]) + double(mfloor)) - mean
+                sq += dv * dv
+            }
+            let denom = sqrt(sq / double(valid - 1)) + 1e-5lf
+            for (i in range(nlen)) {
+                want[i * nmel + j] = i < valid ? float((log(double(x[i * nmel + j]) + double(mfloor)) - mean) / denom) : 0.0
+            }
+        }
+        var ka = CnMelNormArgs(nmel = uint(nmel), nlen = uint(nlen), valid = uint(valid), mfloor = mfloor)
+        let bx = mc |> io_(x)
+        let ran = mc |> cell_record(t, tag) $(enc : MetalComputeEncoder?) {
+            invoke(kd.enc, enc, pso, mc.buf[bx], ka, int64(nmel))
+        }
+        return if (!ran)
+        check_buf(t, tag, mc.buf[bx], want, BAR_APPROX, Shape(row_width = nmel))
+    }
+}
+
+//! The whisper-class projector tails' two row kernels at a width off the 64-thread group: the pair pool against the
+//! mean of each row pair, the row-split gate against silu(second half) * first half - the fixture's halves differ, so
+//! the gate with its halves swapped misses on most elements (asserted on the host).
+def private tw_tail_rows_gate(t : T?; var dev, queue) {
+    with_metal_cell(dev, queue) $(var mc : MetalCell) {
+        var err : string
+        let kp = kernel_of(@@enc_tw_pool2)
+        let kg = kernel_of(@@enc_tw_swiglu_rows)
+        var pso_p = mc |> keep_stamp(kp, err)
+        return if (!pso_ok(t, "tw_pool2", pso_p, err))
+        var pso_g = mc |> keep_stamp(kg, err)
+        return if (!pso_ok(t, "tw_swiglu_rows", pso_g, err))
+        let width = 70
+        let rows = 5
+        let total = rows * width
+        var inscope x <- [for (i in range(2 * total)); float((i * 37) % 101 - 50) * 0.043]
+        var inscope pooled <- [for (i in range(total)); 0.5 * (x[(i / width) * 2 * width + i % width] + x[(i / width) * 2 * width + width + i % width])]
+        var inscope gated : array<float>
+        var inscope swapped : array<float>
+        for (i in range(total)) {
+            let a = double(x[(i / width) * 2 * width + i % width])
+            let g = double(x[(i / width) * 2 * width + width + i % width])
+            gated |> push(float(g / (1.0lf + exp(-g)) * a))
+            swapped |> push(float(a / (1.0lf + exp(-a)) * g))
+        }
+        var apart = 0
+        for (a, b in gated, swapped) {
+            apart += abs(a - b) > 1e-3 ? 1 : 0
+        }
+        t |> success(apart > total / 2, "tw_swiglu_rows: the fixture tells the halves apart ({apart} of {total})")
+        var ka = TwRowsArgs(width = uint(width), total = uint(total))
+        let bx = mc |> in_(x)
+        let bp = mc |> out_(total)
+        let bg = mc |> out_(total)
+        let ran = mc |> cell_record(t, "tw_tail_rows") $(enc : MetalComputeEncoder?) {
+            invoke(kp.enc, enc, pso_p, mc.buf[bx], mc.buf[bp], ka, int64(total))
+            invoke(kg.enc, enc, pso_g, mc.buf[bx], mc.buf[bg], ka, int64(total))
+        }
+        return if (!ran)
+        check_buf(t, "tw_pool2", mc.buf[bp], pooled, BAR_APPROX, Shape(row_width = width))
+        check_buf(t, "tw_swiglu_rows", mc.buf[bg], gated, BAR_APPROX, Shape(row_width = width))
+    }
+}
+
+//! A vision tail's row standardize, in place, at a width off the 64-thread group: (x * scale - b[c]) * m[c] against the
+//! host form, two rows past the run left as they were; the form with no scale misses on most elements (asserted on the host).
+def private tw_affine_gate(t : T?; var dev, queue) {
+    let tag = "tw_affine_rows"
+    with_metal_cell(dev, queue) $(var mc : MetalCell) {
+        var err : string
+        let kd = kernel_of(@@enc_tw_affine_rows)
+        var pso = mc |> keep_stamp(kd, err)
+        return if (!pso_ok(t, tag, pso, err))
+        let width = 70
+        let rows = 5
+        let total = rows * width
+        let scale = 27.712812   // sqrt(768)
+        var inscope x <- [for (i in range((rows + 2) * width)); float((i * 37) % 101 - 50) * 0.043]
+        var inscope b <- [for (i in range(width)); float((i * 7) % 13 - 6) * 0.31]
+        var inscope m <- [for (i in range(width)); 0.5 + float((i * 5) % 11) * 0.17]
+        var inscope want := x
+        var apart = 0
+        for (i in range(total)) {
+            want[i] = (x[i] * scale - b[i % width]) * m[i % width]
+            apart += abs(want[i] - (x[i] - b[i % width]) * m[i % width]) > 1e-3 ? 1 : 0
+        }
+        t |> success(apart > total / 2, "{tag}: the fixture tells the scale apart ({apart} of {total})")
+        var ka = TwAffineArgs(width = uint(width), total = uint(total), scale = scale)
+        let bx = mc |> io_(x)
+        let bb = mc |> in_(b)
+        let bm = mc |> in_(m)
+        let ran = mc |> cell_record(t, tag) $(enc : MetalComputeEncoder?) {
+            invoke(kd.enc, enc, pso, mc.buf[bx], mc.buf[bb], mc.buf[bm], ka, int64(total))
+        }
+        return if (!ran)
+        check_buf(t, tag, mc.buf[bx], want, BAR_APPROX, Shape(row_width = width))
+    }
+}
+
+//! A vision tail's grid mean pool at a width off the 64-thread group: a 6 x 4 row grid pooled 2 x 2 into 3 x 2 rows
+//! against the host mean of each block; the pool along the other axis alone misses on most elements (asserted on the host).
+def private tw_pool2d_gate(t : T?; var dev, queue) {
+    let tag = "tw_pool2d"
+    with_metal_cell(dev, queue) $(var mc : MetalCell) {
+        var err : string
+        let kd = kernel_of(@@enc_tw_pool2d)
+        var pso = mc |> keep_stamp(kd, err)
+        return if (!pso_ok(t, tag, pso, err))
+        let width = 70
+        let gw = 6
+        let gh = 4
+        let k = 2
+        let ow = gw / k
+        let total = ow * (gh / k) * width
+        var inscope x <- [for (i in range(gw * gh * width)); float((i * 37) % 101 - 50) * 0.043]
+        var inscope want : array<float>
+        var inscope row_only : array<float>
+        for (i in range(total)) {
+            let o = i / width
+            let c = i % width
+            var sum = 0.0lf
+            var row = 0.0lf
+            for (dy in range(k)) {
+                for (dx in range(k)) {
+                    let v = double(x[(((o / ow) * k + dy) * gw + (o % ow) * k + dx) * width + c])
+                    sum += v
+                    row += dy == 0 ? v : 0.0lf
+                }
+            }
+            want |> push(float(sum / double(k * k)))
+            row_only |> push(float(row / double(k)))
+        }
+        var apart = 0
+        for (a, b in want, row_only) {
+            apart += abs(a - b) > 1e-3 ? 1 : 0
+        }
+        t |> success(apart > total / 2, "{tag}: the fixture tells a one-axis pool apart ({apart} of {total})")
+        var ka = TwPool2dArgs(width = uint(width), gw = uint(gw), k = uint(k), ow = uint(ow), total = uint(total))
+        let bx = mc |> in_(x)
+        let by = mc |> out_(total)
+        let ran = mc |> cell_record(t, tag) $(enc : MetalComputeEncoder?) {
+            invoke(kd.enc, enc, pso, mc.buf[bx], mc.buf[by], ka, int64(total))
+        }
+        return if (!ran)
+        check_buf(t, tag, mc.buf[by], want, BAR_APPROX, Shape(row_width = width))
+    }
+}
+
 //! A 1x1 conv's bias and ReLU over its rows, in place: max(x + b, 0) against the same f32 form, the fixture on
 //! both sides of zero.
 def private bias_relu_rows_gate(t : T?; var dev, queue) {
@@ -2725,6 +2896,10 @@ def test_metal_prefill_kernels(t : T?) {
                 pk_front_conv_gate(t, dev, queue, true)
                 pk_front_conv_gate(t, dev, queue, false)
                 pk_xf_gate(t, dev, queue)
+                cn_melnorm_gate(t, dev, queue)
+                tw_tail_rows_gate(t, dev, queue)
+                tw_pool2d_gate(t, dev, queue)
+                tw_affine_gate(t, dev, queue)
                 bias_relu_rows_gate(t, dev, queue)
                 st2_conv_gate(t, dev, queue, false, false)
                 st2_conv_gate(t, dev, queue, true, false)
diff --git a/modules/dasLLAMA/tests/test_model_image.das b/modules/dasLLAMA/tests/test_model_image.das
index d60e824523..43be9c72e0 100644
--- a/modules/dasLLAMA/tests/test_model_image.das
+++ b/modules/dasLLAMA/tests/test_model_image.das
@@ -1255,7 +1255,7 @@ def test_whisper_metal_tower(tst : T?) {
             t |> equal(chunks, 1l, "jfk is one 30s chunk")
             t |> equal(s2.blocks - s1.blocks, 4l * chunks, "blocks delta = n_layer x chunks (tiny = 4)")
             t |> equal(s2.rows - s1.rows, 1500l * chunks, "rows delta = n_ctx x chunks")
-            t |> equal(s2.convs - s1.convs, 0l, "tiny's 3x80 im2col width keeps the CPU conv (the shape carve-out)")
+            t |> equal(s2.convs - s1.convs, chunks, "tiny's 3 x 80 conv columns pad to 256: the conv front served on the device")
             to_log(LOG_INFO, "whisper tiny mtower CPU eyeball: '{cpu.text}'\n")
             to_log(LOG_INFO, "whisper tiny mtower GPU eyeball: '{gpu.text}'\n")
             t |> success(!empty(gpu.text), "non-empty transcript")
@@ -1308,42 +1308,38 @@ def test_whisper_metal_tower(tst : T?) {
             t |> success(z_text != cpu.text, "a zeroed twin layer CHANGES the GPU transcript (the twin is read)")
             set_metal_tensor_crowns("")
             metal_prefill_shutdown()
-            // the q8 SERVING DEFAULT declines (quant_mode) and never dispatches — the shipped path stays CPU
+            // the q8 SERVING DEFAULT serves on the tower: its block GEMMs read the q8 planes as a device blob
             var inscope w8 = WhisperModel()
             var inscope stg8 <- stage_whisper_model(path, true)
             mint_whisper_model(stg8, w8)
             t |> success(w8.enc.q8, "the q8 flavor is on the q8 rail")
+            set_metal_tower(false)
+            let q8_cpu = wdec_transcribe(w8, samples)
+            set_metal_tower(true)
             let sq0 = metal_tower_stats()
-            var q8_text = ""
-            with_dasllama_jobque() {
-                var s8 <- create_session(w8)
-                transcribe(w8, s8, samples) $(seg) {
-                    q8_text += seg.text
-                }
-                delete s8
-            }
+            let tq0 = metal_tower_f16_encodes()
+            let dq0 = metal_tower_declines()?["quant_mode"] ?? 0l
+            let q8_gpu = wdec_transcribe(w8, samples)
             let sq1 = metal_tower_stats()
-            t |> equal(sq1.encodes, sq0.encodes, "q8 default never dispatches the tower")
-            t |> equal(sq1.declines - sq0.declines, 1l, "q8 default records the quant_mode decline")
-            t |> success(key_exists(metal_tower_declines(), "quant_mode"), "the decline reason is quant_mode")
-            t |> success(!empty(q8_text), "q8 default still transcribes (CPU serves)")
-            // required-mode contract: a capability decline (quant_mode) under MetalMode.required
-            // panics instead of silently CPU-serving; the knob decline is POLICY and never does
-            set_metal_mode(MetalMode.required)
-            var tripped = false
-            try {
-                with_dasllama_jobque() {
-                    var s9 <- create_session(w8)
-                    transcribe(w8, s9, samples) $(seg) {
-                        pass
-                    }
-                    delete s9
-                }
-            } recover {
-                tripped = true
+            to_log(LOG_INFO, "whisper tiny q8 mtower CPU eyeball: '{q8_cpu}'\n")
+            to_log(LOG_INFO, "whisper tiny q8 mtower GPU eyeball: '{q8_gpu}'\n")
+            t |> equal(sq1.encodes - sq0.encodes, 1l, "q8: one GPU chunk")
+            t |> equal(sq1.blocks - sq0.blocks, 4l, "q8: blocks delta = n_layer (tiny = 4)")
+            t |> equal((metal_tower_declines()?["quant_mode"] ?? 0l) - dq0, 0l, "q8: no quant_mode decline")
+            t |> equal(metal_tower_f16_encodes(), tq0, "q8: the halfword twin route stays out of it")
+            t |> success(!empty(q8_gpu) && q8_gpu == q8_cpu, "q8: transcript-exact CPU vs GPU")
+            // the control: a q8 tower with one layer's GEMM planes zeroed, through the device chain, reads another text
+            var inscope wz8 = WhisperModel()
+            var inscope stgz8 <- stage_whisper_model(path, true)
+            let zq = stgz8.e.enc.qlayers_off + 2l * stgz8.e.enc.qlayer_stride
+            for (i in range64(stgz8.e.enc.qlayer_stride)) {
+                stgz8.enc.qblob[zq + i] = int8(0)
             }
-            set_metal_mode(MetalMode.when_available)
-            t |> success(tripped, "required mode: the q8 tower decline panics")
+            mint_whisper_model(stgz8, wz8)
+            let sz0 = metal_tower_stats()
+            let zq_text = wdec_transcribe(wz8, samples)
+            t |> equal(metal_tower_stats().encodes - sz0.encodes, 1l, "q8 control: the zeroed tower served on the device")
+            t |> success(zq_text != q8_gpu, "q8 control: a zeroed layer CHANGES the GPU transcript (the q8 blob is read)")
             // the POLICY class: a knob decline never panics, even under required mode
             set_metal_mode(MetalMode.required)
             set_metal_tower(false)
@@ -1468,7 +1464,7 @@ def test_whisper_metal_cross_kv(tst : T?) {
             t |> success(rearm_text == gpu_text, "post-shutdown transcript unchanged")
             // the serving FLOOR: at the default min_d, tiny cross-KV-serves but never steps,
             // and the small decline is recorded as policy
-            set_metal_wdec_step_min_d(1024l)
+            set_metal_wdec_step_min_d(METAL_WDEC_STEP_MIN_D)
             let sm0 = metal_wdec_stats()
             let small_text = wdec_transcribe(w8, samples)
             let sm1 = metal_wdec_stats()
@@ -1711,6 +1707,24 @@ def test_parakeet_tower_q8_decline(tst : T?) {
             t |> success(!empty(text), "transcript non-empty")
             t |> equal(enc_delta, 0l, "no tower encodes on the q8 lane")
             t |> success(dec_delta >= 1l, "the quant_mode decline is counted ({dec_delta})")
+            // required-mode contract: a capability decline (quant_mode) under MetalMode.required
+            // panics instead of silently CPU-serving
+            var tripped = false
+            let mode_was = get_metal_mode()
+            set_metal_mode(MetalMode.required)
+            try {
+                with_dasllama_jobque_() {
+                    var inscope m = AsrModel(kind = AsrKind.parakeet)
+                    var inscope stg <- stage_parakeet_model(path, true)
+                    mint_parakeet_model(stg, m.pk, true)
+                    var inscope s <- create_session(m, "en")
+                    transcribe(m, s, samples)
+                }
+            } recover {
+                tripped = true
+            }
+            set_metal_mode(mode_was)
+            t |> success(tripped, "required mode: the q8 tower decline panics")
             delete samples
         } else {
             t |> skip("no Metal build - the parakeet FastConformer driver has no device to decline")
@@ -2204,11 +2218,21 @@ def test_gemma4a_transcribe_q8_ab(t : T?) {
 
 [test]
 def test_gemma4a_tower_metal(t : T?) {
-    t |> run("gemma4a tower: the Metal Conformer block loop matches the CPU f32 rail on jfk") @(t : T?) {
+    g4a_tower_metal_cell(t, "E2B", "gemma-4-E2B-it-Q8_0.gguf", "mmproj-gemma-4-E2B-it-bf16.gguf", 1536l)
+}
+
+//! E4B's audio embedder widens the encoder's 1536 to the decoder's 2560, where E2B's is square
+[test]
+def test_gemma4a_tower_metal_e4b(t : T?) {
+    g4a_tower_metal_cell(t, "E4B", "gemma-4-E4B-it-Q8_0.gguf", "mmproj-gemma-4-E4B-it-BF16.gguf", 2560l)
+}
+
+def private g4a_tower_metal_cell(tst : T?; tag, dec_file, mmp_file : string; want_proj : int64) {
+    tst |> run("gemma4a tower {tag}: the Metal Conformer chain, the projector tail on the device, matches the CPU f32 rail on jfk") @(t : T?) {
         static_if (typeinfo builtin_module_exists(das_metal)) {
             return if (!family_on(t, "gemma4a") || !arm_on(t, "mtower") || !jit_only(t))
-            let dec_path = path_join(models_dir(), "gemma-4-E2B-it-Q8_0.gguf")
-            let mmp_path = path_join(models_dir(), "mmproj-gemma-4-E2B-it-bf16.gguf")
+            let dec_path = path_join(models_dir(), dec_file)
+            let mmp_path = path_join(models_dir(), mmp_file)
             if (!model_available(t, dec_path) || !model_available(t, mmp_path)) return
             var samples <- load_audio_16k_mono(path_join(models_dir(), "jfk.wav"))
             if (empty(samples)) {
@@ -2228,6 +2252,9 @@ def test_gemma4a_tower_metal(t : T?) {
                 set_gemma4a_q8(false)
                 var inscope enc <- load_gemma4a_encoder(mmp_path)
                 t |> success(!enc.q8, "tower is on the f32 rail")
+                t |> equal(enc.proj_dim, want_proj, "the embedder projects to the decoder's width")
+                t |> equal(enc.proj_dim, dec.config.dim)
+                t |> equal(gemma4a_mid_dim(enc), 1536l, "the encoder's own output width")
                 nlayer = enc.n_layer
                 set_metal_tower(false)
                 var inscope s <- create_gemma4a_asr_session(dec)
@@ -2252,6 +2279,7 @@ def test_gemma4a_tower_metal(t : T?) {
                 gemma4a_log_mel(enc, samples, 0l, long_length(samples), stg)
                 gemma4a_encode(enc, stg)
                 enc_rel_l2 = rel_l2(stg.out, stc.out)
+                t |> success(stg.out_ready && !stc.out_ready, "the device leg ran the projector tail, the CPU leg its own")
                 reset_gemma4a_q8()
                 delete dec
             }
@@ -2320,13 +2348,15 @@ def test_canary_tower_metal(t : T?) {
                 canary_encode(enc, stc)
                 set_metal_tower(true)
                 canary_log_mel(enc, samples, stg)
-                let e0 = metal_tower_stats().encodes
+                let e0 = metal_tower_stats()
                 canary_encode(enc, stg)
-                rows_gpu = metal_tower_stats().encodes - e0
+                rows_gpu = metal_tower_stats().encodes - e0.encodes
+                t |> equal(metal_tower_stats().convs - e0.convs, 1l, "the mel and the subsample front served on the device")
                 enc_rel_l2 = rel_l2(stg.out, stc.out)
-                // the control: the same clip with its mel scaled x3 through the GPU chain must red the bar
-                for (i in range(length(stg.mel))) {
-                    stg.mel[i] *= 3.0
+                // the control: the device front reads the windowed frames, so the clip with the first half of them
+                // silenced, through the GPU chain, must red the bar (a scaled clip would not: the mel normalizes per feature)
+                for (i in range(length(stg.xw) / 2)) {
+                    stg.xw[i] = 0.0
                 }
                 canary_encode(enc, stg)
                 poison_rel_l2 = rel_l2(stg.out, stc.out)
diff --git a/modules/dasLLAMA/tests/test_scheduler.das b/modules/dasLLAMA/tests/test_scheduler.das
index 2748ad153f..564057fbee 100644
--- a/modules/dasLLAMA/tests/test_scheduler.das
+++ b/modules/dasLLAMA/tests/test_scheduler.das
@@ -910,10 +910,38 @@ def test_scheduler_media_splice(t : T?) {   // nolint:STYLE038 — one model loa
                 var got <- toks_of(events, 1l)
                 t |> success(ids_equal(got, base.toks), "arm {arm}: media stream == the all-token stream")
                 t |> equal(finished_of(events, 1l).n_prompt, np)   // usage counts the rows as positions
+                t |> equal(sch.prefill_evals, 1l, "arm {arm}: the span and the text around it are one prefill call")
                 delete got
                 delete events
                 delete sch
             }
+            // a chunk of text is all a span's call carries: the head rides it, the tail past the chunk evals on its own
+            var sch_cut <- create_scheduler(m, 1l, 4l, 8l, idle_chunk_tokens = 0l)
+            var events_cut : array<SchedEvent>
+            var req_cut <- media_req(m, 2l, prompt, 4l, 10l, false, greedy, 6l)
+            t |> success(submit(m, sch_cut, req_cut), "chunk-bounded media stream queued")
+            drain(m, sch_cut, events_cut)
+            var got_cut <- toks_of(events_cut, 2l)
+            t |> success(ids_equal(got_cut, base.toks), "a body cut at the chunk == the all-token stream")
+            t |> equal(sch_cut.prefill_evals, 1l + (np - 14l + 7l) / 8l, "the body takes the head, the span and four tail tokens; the rest goes a chunk a call")
+            delete got_cut
+            delete events_cut
+            delete sch_cut
+            // a non-causal span with text either side is generate_embd's span form in one call
+            var mid_ref <- embd_span_generate(m, prompt, 4l, 10l, SamplingParams(temp = 0.8, top_k = 40l), 8l, SPAN_SEED)
+            var sch_mid <- create_scheduler(m, 1l, 4l, 64l)
+            var events_mid : array<SchedEvent>
+            var req_mid <- media_req(m, 3l, prompt, 4l, 10l, true, SamplingParams(temp = 0.8, top_k = 40l), 8l)
+            req_mid.seed = SPAN_SEED
+            t |> success(submit(m, sch_mid, req_mid), "non-causal mid-prompt media stream queued")
+            drain(m, sch_mid, events_mid)
+            var got_mid <- toks_of(events_mid, 3l)
+            t |> success(ids_equal(got_mid, mid_ref), "a non-causal span between text == generate_embd's span form")
+            t |> equal(sch_mid.prefill_evals, 1l)
+            delete got_mid
+            delete events_mid
+            delete sch_mid
+            delete mid_ref
             // the non-causal flag reaches the kernel THROUGH the scheduler: with it set the arm must
             // match generate_embd's span form, not the causal one. The span is [1, np) — everything
             // past BOS — and the streams are sampled under one seed: the span moves the prompt's
@@ -948,10 +976,8 @@ def test_scheduler_media_splice(t : T?) {   // nolint:STYLE038 — one model loa
             delete sch_nc
             delete span_ref
 
-            // paged: the prefix cache is keyed on TOKEN IDS, and a media stream's KV past the splice
-            // does not follow from them — it must neither attach a hit nor donate. Prime the cache
-            // with a plain stream carrying the media stream's EXACT token prompt: the ids match, so
-            // only the bypass keeps those pages from being attached over the splice.
+            // paged: a media span's positions enter the prompt as ids of its rows' content, so the prefix cache
+            // matches across a span as across text. Prime with a plain stream carrying the media stream's text.
             let mlo = 20l
             let mhi = 26l
             var schp <- create_scheduler(m, 1l, 4l, 64l, 16l)
@@ -966,11 +992,50 @@ def test_scheduler_media_splice(t : T?) {   // nolint:STYLE038 — one model loa
             var r1 <- media_req(m, 10l, prompt, mlo, mhi, false, greedy, 6l)
             t |> success(submit(m, schp, r1), "paged media stream queued")
             drain(m, schp, ev)
-            t |> equal(finished_of(ev, 10l).n_cached, 0l)   // no attach: those ids are not this KV
-            t |> equal(schp.cached_tokens, 0l)
+            t |> equal(finished_of(ev, 10l).n_cached, mlo)   // the text ahead of the span attaches; the span's ids are no token's, so the hit stops there
             var paged_toks <- toks_of(ev, 10l)
             t |> success(ids_equal(paged_toks, base.toks), "paged media stream == the all-token stream")
-            t |> equal(prefix_held_groups(schp.prefix), primed)   // and no donate on the way out
+            t |> success(prefix_held_groups(schp.prefix) > primed, "the media stream donates its pages")
+            // the same media again: everything but the last position attaches, the span included
+            ev |> clear()
+            var r2 <- media_req(m, 11l, prompt, mlo, mhi, false, greedy, 6l)
+            t |> success(submit(m, schp, r2), "the same media stream queued again")
+            drain(m, schp, ev)
+            t |> success(finished_of(ev, 11l).n_cached > mhi, "asked again, the span attaches off the cache ({finished_of(ev, 11l).n_cached} of {np} positions)")
+            var again_toks <- toks_of(ev, 11l)
+            t |> success(ids_equal(again_toks, base.toks), "the attached span reads the same stream")
+            // ...and with no rows at all: the request counts on the cache for the span
+            ev |> clear()
+            var r3 <- media_req(m, 12l, prompt, mlo, mhi, false, greedy, 6l)
+            splice_to_span(r3)
+            delete r3.spans[0].rows
+            t |> success(submit(m, schp, r3), "a rowless request queued")
+            drain(m, schp, ev)
+            var rowless_toks <- toks_of(ev, 12l)
+            t |> equal(finished_of(ev, 12l).finish, "length")
+            t |> success(ids_equal(rowless_toks, base.toks), "a span the cache holds needs no rows")
+            // other rows at the same place share only the text ahead of them (the control)
+            ev |> clear()
+            var other <- [for (k in range64(np)); k >= mlo && k < mhi ? prompt[np - 1l - (k - mlo)] : prompt[k]]
+            var r4 <- media_req(m, 13l, other, mlo, mhi, false, greedy, 6l)
+            t |> success(submit(m, schp, r4), "a stream with other rows queued")
+            drain(m, schp, ev)
+            t |> equal(finished_of(ev, 13l).n_cached, mlo)
+            // a rowless request on a cache that never saw the span is told so, and donates nothing
+            var schl <- create_scheduler(m, 1l, 4l, 64l, 16l)
+            var evl : array<SchedEvent>
+            var r5 <- media_req(m, 14l, prompt, mlo, mhi, false, greedy, 6l)
+            splice_to_span(r5)
+            delete r5.spans[0].rows
+            t |> success(submit(m, schl, r5), "a rowless request on a cold cache queued")
+            drain(m, schl, evl)
+            t |> equal(finished_of(evl, 14l).finish, "media_lost")
+            t |> equal(prefix_held_groups(schl.prefix), 0l)
+            delete evl
+            delete schl
+            delete other
+            delete rowless_toks
+            delete again_toks
             delete paged_toks
             delete text_only
             delete ev
@@ -1150,6 +1215,30 @@ def private embd_mrope_generate(m : Model; prompt : array<int64>; lo, hi : int64
     return <- out
 }
 
+//! Paged: the grid span donates, and the same request asked again attaches it off the cache - the session's rope advance
+//! comes back with it, or every position past the span ropes that advance off. Both streams run the flat reference's lane
+//! (classic prefill, the std decode, the CPU rails - the caller's pins); the paged K/V layout alone differs.
+def private mrope_paged_leg(t : T?; m : Model; prompt : array<int64>; lo, hi : int64; grid : int2; mref : array<int64>) {
+    var schp <- create_scheduler(m, 1l, 4l, 64l, 16l)
+    var ep : array<SchedEvent>
+    for (id in fixed_array(31l, 32l)) {
+        var rqp <- media_req(m, id, prompt, lo, hi, true, SamplingParams(), 8l, grid)
+        t |> success(submit(m, schp, rqp), "paged mrope stream {id} queued")
+        scheduler_step(m, schp, ep)   // admits the stream and prefills what the cache does not hold
+        t |> success(length(schp.streams) == 1 && schp.streams[0].session.rope_pos_delta == int64(max(grid.x, grid.y)) - (hi - lo),
+            "paged mrope stream {id}: the session ropes past the span by the grid's advance ({max(grid.x, grid.y)} positions for {hi - lo} rows)")
+        drain(m, schp, ep)
+        var gp <- toks_of(ep, id)
+        to_log(LOG_INFO, "paged mrope stream {id} (cached {finished_of(ep, id).n_cached}): {eyeball_text(m, gp)}\nits grid reference: {eyeball_text(m, mref)}\n")
+        t |> success(ids_equal(gp, mref), "paged mrope stream {id} == the grid reference")
+        delete gp
+    }
+    t |> equal(finished_of(ep, 31l).n_cached, 0l, "the first paged stream finds a cold cache")
+    t |> success(finished_of(ep, 32l).n_cached >= hi, "asked again, the grid span attaches off the cache ({finished_of(ep, 32l).n_cached} of {length(prompt)} positions, the span ends at {hi})")
+    delete ep
+    delete schp
+}
+
 [test]
 def test_scheduler_mrope(t : T?) {
     t |> run("media_grid: the mrope walk reaches the quantum and survives the batched decode (needs SmolLM2-135M)") @(t : T?) {
@@ -1199,6 +1288,7 @@ def test_scheduler_mrope(t : T?) {
             t |> success(ids_equal(g1, mref), "batched mrope stream == its solo grid reference")
             t |> success(ids_equal(g2, tref.toks), "batched text stream == its solo reference")
             t |> success(schb.sum_batch >= 4l, "decode steps actually batched (sum batch {schb.sum_batch})")
+            mrope_paged_leg(t, m, prompt, lo, hi, grid, mref)
             set_fused_decode(prev_fused)
             set_prefill_attn_mode(saved_mode)
             delete g1
@@ -1269,3 +1359,149 @@ def test_scheduler_mrope_validation(t : T?) {
         }
     }
 }
+
+// ===== inline spans: a prefix hit stops short of a span it would cut, and submit refuses malformed spans by panic =====
+
+//! [lo, hi) of `prompt` INLINE as one non-causal span: the rows are the prompt's own embedding rows, the position ids
+//! `key_a`'s for the span's first `split` rows and `key_b`'s past them
+def private inline_span_req(m : Model; id : int64; prompt : array<int64>; lo, hi, split : int64; key_a, key_b : uint64;
+                            params : SamplingParams; max_new : int64) : PendingReq {
+    var r <- PendingReq(id = id, params = params, max_new = max_new)
+    r.prompt <- [for (k in range64(long_length(prompt))); (k < lo || k >= hi) ? prompt[k] : media_position_id(k - lo < split ? key_a : key_b, k - lo)]
+    var mid <- [for (k in range64(lo, hi)); prompt[k]]
+    var sp <- MediaSpan(at = lo, n = hi - lo, non_causal = true)
+    sp.rows |> resize((hi - lo) * m.config.dim)
+    embed_text_rows(m, mid, sp.rows, 0l)
+    r.spans |> emplace(sp)
+    delete mid
+    return <- r
+}
+
+[test]
+def test_scheduler_span_cut(t : T?) {
+    t |> run("a prefix hit that ends inside a span is no hit: the span evals whole (needs SmolLM2-135M)") @(t : T?) {
+        return if (model_missing(t))
+        with_dasllama_jobque() {
+            var m <- load_capped_cpu(128l)
+            let saved_mode = get_prefill_attn_mode()
+            set_prefill_attn_mode(AttnPrefillMode.classic)   // the span's call moves the eval boundaries: classic alone is bit-exact under them
+            var prompt <- encode(m, "The quick brown fox jumps over the lazy dog while the little robot watches from a small hill near the old village bakery and counts every bird that crosses the evening sky", true, false)
+            let np = long_length(prompt)
+            let lo = 4l
+            let hi = 24l
+            let split = 10l   // the second request shares the text and the span's first 10 ids: its hit would end at 14, inside [4, 24)
+            t |> success(np > hi + 4l, "the prompt leaves a tail past the span ({np} tokens)")
+            var other <- [for (k in range64(np)); (k >= lo + split && k < hi) ? prompt[np - 1l - (k - lo - split)] : prompt[k]]
+            t |> success(!ids_equal(other, prompt), "the second span's rows past the split are other tokens'")
+            let greedy = SamplingParams()
+            var ref_a <- embd_span_generate(m, prompt, lo, hi, greedy, 6l)
+            var ref_b <- embd_span_generate(m, other, lo, hi, greedy, 6l)
+            var sch <- create_scheduler(m, 1l, 4l, 64l, 16l)
+            var ev : array<SchedEvent>
+            var ra <- inline_span_req(m, 1l, prompt, lo, hi, hi - lo, 0xa11ul, 0xa11ul, greedy, 6l)
+            t |> success(submit(m, sch, ra), "the first span stream queued")
+            drain(m, sch, ev)
+            var got_a <- toks_of(ev, 1l)
+            to_log(LOG_INFO, "span stream A: {eyeball_text(m, got_a)}\nits reference: {eyeball_text(m, ref_a)}\n")
+            t |> success(ids_equal(got_a, ref_a), "the first span stream == generate_embd's span form")
+            t |> success(prefix_held_groups(sch.prefix) > 0l, "the first stream donates its pages")
+            var rb <- inline_span_req(m, 2l, other, lo, hi, split, 0xa11ul, 0xb22ul, greedy, 6l)
+            t |> success(submit(m, sch, rb), "the second span stream queued")
+            drain(m, sch, ev)
+            var got_b <- toks_of(ev, 2l)
+            to_log(LOG_INFO, "span stream B (cached {finished_of(ev, 2l).n_cached}): {eyeball_text(m, got_b)}\nits reference: {eyeball_text(m, ref_b)}\n")
+            t |> success(finished_of(ev, 2l).n_cached <= lo, "a hit ending inside the span attaches nothing past the span's start ({finished_of(ev, 2l).n_cached}, the span opens at {lo})")
+            t |> success(ids_equal(got_b, ref_b), "the second span stream == its own generate_embd span form")
+            delete got_b
+            delete rb
+            delete got_a
+            delete ra
+            delete ev
+            delete sch
+            delete ref_b
+            delete ref_a
+            delete other
+            delete prompt
+            set_prefill_attn_mode(saved_mode)
+            delete m
+        }
+    }
+}
+
+//! whether `submit` refuses `req` by panic
+def private submit_panics(m : Model; var sch : Scheduler; var req : PendingReq) : bool {
+    var tripped = false
+    try {
+        submit(m, sch, req)
+    } recover {
+        tripped = true
+    }
+    return tripped
+}
+
+//! a well-formed request: the prompt's [4, 10) inline as one span under one key
+def private span_ok_req(m : Model; id : int64; prompt : array<int64>) : PendingReq {
+    return <- inline_span_req(m, id, prompt, 4l, 10l, 6l, 0x5a5ul, 0x5a5ul, SamplingParams(), 4l)
+}
+
+//! the well-formed request's prompt with its one span replaced by rowless spans at `spans`' (at, n) pairs
+def private spans_req(m : Model; id : int64; prompt : array<int64>; spans : array<int2>) : PendingReq {
+    var r <- span_ok_req(m, id, prompt)
+    delete r.spans
+    r.spans |> reserve(length(spans))
+    for (s in spans) {
+        r.spans |> emplace(MediaSpan(at = int64(s.x), n = int64(s.y), non_causal = true))
+    }
+    return <- r
+}
+
+[test]
+def test_scheduler_span_validation(t : T?) {
+    t |> run("submit panics on malformed inline spans (needs SmolLM2-135M)") @(t : T?) {
+        return if (model_missing(t))
+        with_dasllama_jobque() {
+            var m <- load_capped_cpu(128l)
+            var prompt <- encode(m, "The quick brown fox jumps over the lazy dog while the little robot watches", true, false)
+            let np = long_length(prompt)
+            t |> success(np > 12l, "the prompt holds the span and text past it ({np} tokens)")
+            var sch <- create_scheduler(m, 1l, 64l, 64l)
+            var ok <- span_ok_req(m, 40l, prompt)
+            t |> success(!submit_panics(m, sch, ok), "a well-formed span submits (the control)")
+            var empty_span <- spans_req(m, 41l, prompt, [int2(5, 0)])   // both rows it reads, [4] and [5], are ids
+            t |> success(submit_panics(m, sch, empty_span), "a span of no rows panics")
+            var backward <- spans_req(m, 42l, prompt, [int2(8, 2), int2(4, 2)])
+            t |> success(submit_panics(m, sch, backward), "spans out of prompt order panic")
+            var overlap <- spans_req(m, 43l, prompt, [int2(4, 4), int2(6, 4)])
+            t |> success(submit_panics(m, sch, overlap), "overlapping spans panic")
+            var past <- spans_req(m, 44l, prompt, [int2(int(np) - 2, 3)])
+            t |> success(submit_panics(m, sch, past), "a span past the prompt's end panics")
+            var on_text <- spans_req(m, 45l, prompt, [int2(3, 7)])
+            t |> success(submit_panics(m, sch, on_text), "a span whose first row is a token panics")
+            var off_end <- spans_req(m, 46l, prompt, [int2(4, 7)])
+            t |> success(submit_panics(m, sch, off_end), "a span whose last row is a token panics")
+            var wide <- span_ok_req(m, 47l, prompt)
+            wide.spans[0].rows |> push(0.0)
+            t |> success(submit_panics(m, sch, wide), "rows one float past the span's width panic")
+            var narrow <- span_ok_req(m, 48l, prompt)
+            narrow.spans[0].rows |> resize(length(narrow.spans[0].rows) - int(m.config.dim))
+            t |> success(submit_panics(m, sch, narrow), "rows a row short of the span panic")
+            var both <- span_ok_req(m, 49l, prompt)
+            both.n_media = 2l
+            both.media_at = np   // a splice past the inline span: folded in, the spans would stand in order
+            both.media_embd |> resize(2l * m.config.dim)
+            t |> success(submit_panics(m, sch, both), "a request with both a splice and inline spans panics")
+            var schd <- create_scheduler(m, 1l, 64l, 64l)
+            set_device_kv(schd, true)
+            var dev <- span_ok_req(m, 50l, prompt)
+            t |> success(submit_panics(m, schd, dev), "device mode: a device-home session serves no inline span either")
+            set_device_kv(schd, false)
+            // a panic inside submit's walk over the spans leaves the refused requests' span arrays locked, so they are
+            // not deleted - the heap goes with the context
+            delete schd
+            delete ok
+            delete sch
+            delete prompt
+            delete m
+        }
+    }
+}
diff --git a/modules/dasLLAMA/tests/test_served_bench.das b/modules/dasLLAMA/tests/test_served_bench.das
index 24ecb2db18..23ba325eb7 100644
--- a/modules/dasLLAMA/tests/test_served_bench.das
+++ b/modules/dasLLAMA/tests/test_served_bench.das
@@ -34,7 +34,7 @@ class FakeChatServer : HvWebServer {
                 respond(server, writer, int(http_status.INTERNAL_SERVER_ERROR), "application/json", "\{\"error\":\"down\"}")
                 return
             }
-            if (find(body, "image_url") >= 0) {   // the image question: one buffered completion, the image's rows in its prompt count
+            if (find(body, "image_url") >= 0 || find(body, "input_audio") >= 0) {   // the media question: one buffered completion, the part's rows in its prompt count
                 respond(server, writer, int(http_status.OK), "application/json", find(body, "\"nousage\"") >= 0 ? replace(SEEN, "\"prompt_tokens\":300", "\"prompt_tokens\":0") : SEEN)
                 return
             }
@@ -57,6 +57,28 @@ class FakeChatServer : HvWebServer {
 }
 
 var g_takes = 0   //! the speech fake's request count, in its own thread's context
+var g_heard : table<string>   //! every upload the speech fake's `seen` model was sent, in its own thread's context
+
+//! what tells one uploaded clip from another: the indices of its samples that are not silence, "" for an upload that is no WAV
+def private upload_key(var req : HttpRequest?) : string {
+    var err = ""
+    let path = create_temp_file("served_bench_upload", ".wav", err)
+    save_form_file(req, "file", path)
+    var samples : array<float>
+    var rate = 0
+    var channels = 0
+    read_wav(path, samples, rate, channels)
+    remove(path)
+    let key = build_string() $(writer) {
+        for (i, s in count(), samples) {
+            if (s != 0.0) {
+                writer |> write("{i} ")
+            }
+        }
+    }
+    delete samples
+    return key
+}
 
 class FakeSpeechServer : HvWebServer {
     def override onInit {
@@ -75,6 +97,12 @@ class FakeSpeechServer : HvWebServer {
             if (model == "slow") {
                 sleep(300u)
             }
+            if (model == "seen") {
+                let upload = upload_key(req)
+                let again = g_heard |> key_exists(upload)
+                g_heard |> insert(upload)
+                return resp |> JSON("\{\"text\":\"{again ? "heard before" : "new"}\"}")
+            }
             return resp |> JSON("\{\"text\":\"hello world\"}")
         }
         POST("/v1/audio/speech") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
@@ -135,6 +163,16 @@ def test_speech_rows_against_fakes(t : T?) {
                 t |> equal(clip_row(Speech(url = speech_url, model = "drift"), clip, "asr clip", "", 3), "", "three reps, three texts")
                 t |> equal(clip_row(Speech(url = speech_url, model = "fail"), clip, "asr clip", "", 3), "", "a failed rep refuses the row")
             }
+            t |> run("every request uploads a clip the server has not heard; a clip that is no WAV goes up as it is") @(t : T?) {
+                let wav = silent_wav(160000)   // ten seconds: the copies differ in one sample picked off the clock
+                t |> equal(clip_row(Speech(url = speech_url, model = "seen"), wav, "asr clip", "", 4), "new", "four reps, four uploads the fake never saw")
+                let copy = unseen_clip(wav)
+                t |> success(!empty(copy) && copy != wav && stat(copy).size == stat(wav).size, "the copy is a file of its own, the clip's size")
+                remove(copy)
+                remove(wav)
+                t |> equal(unseen_clip(clip), "", "no WAV, no copy")
+                t |> equal(clip_row(Speech(url = speech_url, model = "seen"), clip, "asr clip", "", 2), "", "the same bytes twice: the fake's second answer differs and the row is refused")
+            }
             with_test_server(type<FakeChatServer>) $(chat_url) {
                 t |> run("a loaded row stands while the chat turn outlasts its reps") @(t : T?) {
                     let load = LoadJob(url = chat_url, model = "ok", question = "ask", budget = 8)
@@ -356,6 +394,10 @@ def test_turns_against_a_fake_server(t : T?) {
                 var gone <- ["{file}.absent"]
                 let missed = image_rows(Plan(url = base_url, model = "ok", reps = 2), gone, "run")
                 t |> success(missed.rows == 0 && missed.refused == 1, "a missing file refuses its row")
+                let heard = media_rows(Plan(url = base_url, model = "ok", reps = 2), files, "run", true)
+                t |> success(heard.rows == 1 && heard.refused == 0, "one row a chat clip: the file goes up as an input_audio part")
+                let unheard = media_rows(Plan(url = base_url, model = "ok", reps = 2), gone, "run", true)
+                t |> success(unheard.rows == 0 && unheard.refused == 1, "a missing clip refuses its row")
                 delete files
                 delete gone
             }
diff --git a/modules/dasLLAMA/tests/test_vision_chat.das b/modules/dasLLAMA/tests/test_vision_chat.das
index 7b53caef62..df57aebbf5 100644
--- a/modules/dasLLAMA/tests/test_vision_chat.das
+++ b/modules/dasLLAMA/tests/test_vision_chat.das
@@ -244,7 +244,7 @@ def test_vision_chat_e2b_nothink(t : T?) {
             // the model opens with a thought block despite the closed empty prefill; the armed
             // matcher files it as reasoning and the answer is the content half
             let sp = split_reasoning_(chat.tmpl, reply)
-            to_log(LOG_INFO, "vision caption (E2B/gemma4v, thinking off): reasoning {length(sp.reasoning)} chars, content: {replace(sp.content, "\n", "\\n")}\n")
+            to_log(LOG_INFO, "vision caption (E2B/gemma4v, thinking off): {stats(chat.session).n_gen} tokens, reasoning {length(sp.reasoning)} chars, content: {replace(sp.content, "\n", "\\n")}\n")
             tt |> success(n_pieces > 0, "the turn generated tokens")
             tt |> success(find(to_lower(sp.content), "cat") >= 0, "the content half describes the cats as cats")
             tt |> success(find(sp.content, "<channel|>") < 0 && find(sp.content, "<|channel>") < 0, "no channel marker reaches the content half")
diff --git a/modules/dasLLAMA/tests/test_whisper.das b/modules/dasLLAMA/tests/test_whisper.das
index f87515e90b..9bd7f33e06 100644
--- a/modules/dasLLAMA/tests/test_whisper.das
+++ b/modules/dasLLAMA/tests/test_whisper.das
@@ -331,6 +331,7 @@ def test_parakeet_oracle(t : T?) {
             t |> equal(s.detected_lang, "en")
 
             reused_session_leg(t, m, s, samples)
+            heap_flat_leg(t, m, s, samples, "parakeet")
 
             t |> equal(m.pk.q8, !parakeet_gpu_serves(), "default load follows the lane policy - q8 unless the Metal driver serves")
             var inscope mf = AsrModel(kind = AsrKind.parakeet)
@@ -775,6 +776,197 @@ def test_whisper_vulkan_wdec_flush(t : T?) {
     }
 }
 
+//! A whisper.cpp q8_0 bin loads: its Q8_0 tensors read as their blocks' scale times the quants, and it transcribes what the
+//! f16 bin of the same model does.
+[test]
+def test_whisper_q8_0_file(t : T?) {
+    t |> run("ggml-tiny-q8_0.bin: a q8_0 bin loads and reads jfk as the f16 bin does") @(tt : T?) {
+        let f16_path = path_join(whisper_dir(), "ggml-tiny.bin")
+        let q8_path = path_join(whisper_dir(), "ggml-tiny-q8_0.bin")
+        return if (!jit_model_available(tt, f16_path) || !jit_model_available(tt, q8_path))
+        let samples <- load_audio_16k_mono(path_join(models_dir(), "jfk.wav"))
+        if (empty(samples)) {
+            tt |> skip("jfk.wav not present")
+            return
+        }
+        set_asr_fp32(false)
+        set_asr_tower_fp32(false)
+        var inscope m16 <- mint_asr_whisper(f16_path)
+        var inscope m8 <- mint_asr_whisper(q8_path)
+        var from_f16 = ""
+        var from_q8 = ""
+        with_dasllama_jobque_() {
+            var inscope s16 <- create_session(m16)
+            from_f16 = transcribe(m16, s16, samples)
+            var inscope s8 <- create_session(m8)
+            from_q8 = transcribe(m8, s8, samples)
+        }
+        to_log(LOG_INFO, "whisper tiny f16 bin: '{from_f16}'\n")
+        to_log(LOG_INFO, "whisper tiny q8_0 bin: '{from_q8}'\n")
+        tt |> success(!empty(from_q8), "the q8_0 bin transcribes")
+        tt |> equal(from_q8, from_f16, "and reads what the f16 bin reads")
+    }
+}
+
+//! one parakeet bin staged and minted in memory on the lane `q8`, reading `samples`
+def private parakeet_text(path : string; q8 : bool; samples : array<float>) : string {
+    var inscope m = AsrModel(kind = AsrKind.parakeet)
+    var inscope stg <- stage_parakeet_model(path, q8)
+    mint_parakeet_model(stg, m.pk, q8)
+    var text = ""
+    with_dasllama_jobque_() {
+        var inscope s <- create_session(m, "en")
+        text = transcribe(m, s, samples)
+    }
+    return text
+}
+
+//! A parakeet q8_0 bin loads through the reader the whisper bins share, and reads what the f32 bin of the same model does.
+[test]
+def test_parakeet_q8_0_file(t : T?) {
+    t |> run("ggml-parakeet-tdt-0.6b-v3-q8_0.bin: a q8_0 bin loads and reads jfk as the f32 bin does") @(tt : T?) {
+        let f32_path = path_join(whisper_dir(), "ggml-parakeet-tdt-0.6b-v3-f32.bin")
+        let q8_path = path_join(whisper_dir(), "ggml-parakeet-tdt-0.6b-v3-q8_0.bin")
+        return if (!jit_model_available(tt, f32_path) || !jit_model_available(tt, q8_path))
+        let samples <- load_audio_16k_mono(path_join(models_dir(), "jfk.wav"))
+        if (empty(samples)) {
+            tt |> skip("jfk.wav not present")
+            return
+        }
+        let from_f32 = parakeet_text(f32_path, false, samples)
+        let from_q8 = parakeet_text(q8_path, false, samples)
+        to_log(LOG_INFO, "parakeet v3 f32 bin: '{from_f32}'\n")
+        to_log(LOG_INFO, "parakeet v3 q8_0 bin: '{from_q8}'\n")
+        tt |> success(!empty(from_q8), "the q8_0 bin transcribes")
+        tt |> equal(from_q8, from_f32, "and reads what the f32 bin reads")
+    }
+}
+
+//! The Metal tower fills the whisper blocks-with-post-norm seat: the post-norm runs behind the blocks on the device and the
+//! normed rows land in `xb`, where the CPU chain's post-norm would put them.
+[test]
+def test_whisper_metal_ln_post(t : T?) {
+    t |> run("ggml-tiny.bin: the encoder's post-norm on the Metal tower lands the CPU chain's normed rows") @(tt : T?) {
+        static_if (typeinfo builtin_module_exists(das_metal)) {
+            let model_path = path_join(whisper_dir(), "ggml-tiny.bin")
+            return if (!jit_model_available(tt, model_path))
+            let samples <- load_audio_16k_mono(path_join(models_dir(), "jfk.wav"))
+            if (empty(samples)) {
+                tt |> skip("jfk.wav not present")
+                return
+            }
+            var inscope w <- mint_whisper(model_path, false, false, -1l)
+            with_dasllama_jobque_() {
+                var padded : array<float>
+                var mel = WhisperMel()
+                log_mel_whisper(samples, w.mel, w.filters, w.enc.n_mel, padded, mel)
+                var win = MelChunk(n_mel = w.enc.n_mel, n_len = AUDIO_CHUNK_FRAMES)
+                win.data |> resize(w.enc.n_mel * AUDIO_CHUNK_FRAMES)
+                whisper_mel_window(mel, 0l, win)
+                var es <- make_encoder_state(w.enc)
+                set_metal_tower(false)
+                tt |> success(!audio_encode_blocks_ln_post(w.enc, es, win), "tower off: the seat declines and the CPU owes the post-norm")
+                var raw := es.x   // the blocks' rows before the post-norm: the control's reference
+                whisper_encode(w.enc, es, win)
+                var cpu := es.xb
+                set_metal_tower(true)
+                let s0 = metal_tower_stats()
+                tt |> success(audio_encode_blocks_ln_post(w.enc, es, win), "tower on: the seat served the blocks and the post-norm")
+                tt |> equal(metal_tower_stats().encodes - s0.encodes, 1l, "one device encode")
+                // a NaN on either side reads infinite in the difference, and in the scale where it is the reference's: the
+                // ratio is then infinite or NaN, outside the bar
+                let off = logits_maxdiff(es.xb, cpu) / logits_maxabs(cpu)
+                let unnormed = logits_maxdiff(es.xb, raw) / logits_maxabs(raw)
+                var normed := es.xb
+                // the post-norm is the unit: the blocks seat alone gives the device's own block rows, the CPU norms THOSE, and the
+                // device's normed rows must be that image - the block chain's device-vs-CPU distance stays out of the bar
+                audio_encode_blocks(w.enc, es, win)
+                var want : array<float>
+                want |> resize(length(es.x))
+                layernorm_batch(want, es.x, w.enc.fblob, w.enc.lnp_w_off, w.enc.lnp_b_off, w.enc.d_model, w.enc.n_ctx, w.enc.eps)
+                let ln_off = logits_maxdiff(normed, want) / logits_maxabs(want)
+                to_log(LOG_INFO, "whisper tiny ln_post: device norm vs the CPU norm of the device's block rows {ln_off}; vs the CPU chain {off}; vs the un-normed rows {unnormed}\n")
+                tt |> success(ln_off < 1e-4, "the device's post-norm is the CPU post-norm of the same rows ({ln_off})")
+                tt |> success(unnormed > 0.1, "the control: against the rows before the post-norm the compare misses ({unnormed})")
+                delete want
+                delete normed
+                delete raw
+                delete cpu
+                delete es
+                delete win
+                delete mel
+                delete padded
+            }
+            metal_tower_shutdown()
+        } else {
+            tt |> skip("dasMetal not present")
+        }
+    }
+}
+
+//! The Metal decoder leaves a window's cross-KV layouts on the device while its step serves; a first batch past the step's
+//! 32-row cap hands the window to the CPU chain, and the layouts land first.
+[test]
+def test_whisper_metal_wdec_flush(t : T?) {
+    t |> run("ggml-tiny.bin: the waiting cross-KV readback lands when the step declines; the CPU chain over it matches the knob-off chain") @(tt : T?) {
+        static_if (typeinfo builtin_module_exists(das_metal)) {
+            let model_path = path_join(whisper_dir(), "ggml-tiny.bin")
+            return if (!jit_model_available(tt, model_path))
+            let samples <- load_audio_16k_mono(path_join(models_dir(), "jfk.wav"))
+            if (empty(samples)) {
+                tt |> skip("jfk.wav not present")
+                return
+            }
+            set_asr_fp32(false)
+            set_asr_tower_fp32(false)
+            var inscope m <- mint_asr_whisper(model_path)
+            let batch <- [for (i in range(33)); m.whisper.tok_sot + i]   // one past the step's cap, the first batch of a window
+            var batch_moved := batch
+            batch_moved[length(batch_moved) - 1]++
+            var cpu_logits : array<float>
+            var cpu_moved : array<float>
+            var dev_logits : array<float>
+            with_dasllama_jobque_() {
+                set_metal_wdec(false)
+                var inscope sc <- create_session(m)
+                transcribe(m, sc, samples) $(_seg) {}
+                sc.w.ds.n_past = 0l
+                whisper_decode_batch(m.whisper, sc.w.ds, batch)
+                cpu_logits := sc.w.ds.logits
+                sc.w.ds.n_past = 0l
+                whisper_decode_batch(m.whisper, sc.w.ds, batch_moved)
+                cpu_moved := sc.w.ds.logits
+                set_metal_wdec(true)
+                set_metal_wdec_step(true)
+                set_metal_wdec_step_min_d(0l)   // tiny sits under the step's serving floor: with it lifted the step serves and the layouts wait
+                let d0 = metal_wdec_stats()
+                var inscope sg <- create_session(m)
+                transcribe(m, sg, samples) $(_seg) {}
+                let d1 = metal_wdec_stats()
+                tt |> success(d1.windows - d0.windows >= 1l && d1.steps > d0.steps, "the device served the window's cross-KV and its steps ({d1.windows - d0.windows}, {d1.steps - d0.steps})")
+                for (i in range(length(sg.w.ds.kx))) {   // the host layouts are stale by construction: only a flush makes the CPU chain right
+                    sg.w.ds.kx[i] = 0.0
+                }
+                sg.w.ds.n_past = 0l
+                sg.w.ds.gpu_kv_gen = 0l
+                whisper_decode_batch(m.whisper, sg.w.ds, batch)
+                tt |> equal(metal_wdec_stats().steps, d1.steps, "the device served no step of the wide batch: the CPU chain decoded it over the flushed memory")
+                dev_logits := sg.w.ds.logits
+                wdec_flush_compare(tt, m.whisper, cpu_logits, dev_logits, cpu_moved)   // inside the queue: the argmax is the parallel one
+                set_metal_wdec_step_min_d(METAL_WDEC_STEP_MIN_D)
+            }
+            delete cpu_logits
+            delete cpu_moved
+            delete dev_logits
+            delete m
+            metal_wdec_shutdown()
+            metal_tower_shutdown()
+        } else {
+            tt |> skip("dasMetal not present")
+        }
+    }
+}
+
 //! a lifetime cell's seat: tiny on jfk, both drivers on, the q8 default load, one session created for `body` the way a serving
 //! worker reuses one - the decoder's window lifetime across that session's transcriptions is the claim
 def private wdec_lifetime_cell(tt : T?; body : block<(m : AsrModel; var s : AsrSession; samples : array<float>) : void>) {
@@ -869,6 +1061,20 @@ def private session_segs(m; var s; samples : array<float>) : array<TranscribeSeg
     return <- segs
 }
 
+//! A serving worker transcribes clip after clip on one session: the heap after the fourth transcription of a clip is the
+//! heap after the second (within 256 KB), so a transcription frees what it allocates.
+def private heap_flat_leg(t : T?; m; var s; samples : array<float>; tag : string) {
+    for (_i in range(2)) {
+        var inscope warm <- session_segs(m, s, samples)
+    }
+    let h0 = heap_bytes_allocated()
+    for (_i in range(2)) {
+        var inscope again <- session_segs(m, s, samples)
+    }
+    let h1 = heap_bytes_allocated()
+    t |> success(h1 <= h0 + 262144ul, "{tag}: two more transcriptions leave the heap where it stood ({h0} -> {h1} bytes)")
+}
+
 //! a serving worker's session sees clips of every length: a session that read the whole clip reads its first half as a fresh one does
 def private reused_session_leg(t : T?; m; var s; samples : array<float>) {
     var inscope half <- [for (i in range(length(samples) / 2)); samples[i]]
@@ -1073,11 +1279,11 @@ def test_whisper_crowned_word_level(t : T?) {
                 to_log(LOG_INFO, "whisper-tiny crowned q8 jfk eyeball: '{text_default}'\n")
                 to_log(LOG_INFO, "whisper-tiny crowned f32/q8 jfk eyeball: '{text_mixed}'\n")
                 // engage witness - without it a declining driver would compare two CPU
-                // transcripts and pass vacuously. The q8-default ENCODER declines the tower
-                // by design (quant_mode), so the tower delta is the mixed lane's f32 encode
-                // alone; both DECODERS ride the crowned wdec
-                t |> equal(metal_tower_stats().encodes - s0.encodes, 1l,
-                           "the mixed lane's f32 encoder GPU-served (tower encode delta)")
+                // transcripts and pass vacuously. Both ENCODERS serve on the tower - the q8
+                // default off its q8 planes, the mixed lane off its f32 blob - and both
+                // DECODERS ride the crowned wdec
+                t |> equal(metal_tower_stats().encodes - s0.encodes, 2l,
+                           "both lanes' encoders GPU-served (tower encode delta)")
                 t |> success(metal_wdec_stats().steps - w0.steps > 0l,
                              "the crowned decoder served (wdec step delta)")
                 let wa <- word_forms(text_default)
@@ -1095,7 +1301,7 @@ def test_whisper_crowned_word_level(t : T?) {
             set_metal_tower(true)   // restore: the defaults later cells' GPU-serving claims see
             set_metal_wdec(true)
             set_metal_wdec_step(true)
-            set_metal_wdec_step_min_d(1024l)   // the measured serving floor (the declaration default)
+            set_metal_wdec_step_min_d(METAL_WDEC_STEP_MIN_D)   // the measured serving floor (the declaration default)
             delete m
             delete mm
         } else {
@@ -1154,6 +1360,11 @@ def test_canary_qwen_oracle(t : T?) {
                  6540, 315, 5561, 151645])
             check_canary_clip(t, m, path_join(corpus_dir(), "librispeech/05_1089-134686-0004.wav"),
                 [2833, 5779, 29160, 451, 11896, 374, 8580, 389, 498, 13, 7684, 3729, 9972, 151645])
+            var inscope jfk <- load_audio_16k_mono(path_join(corpus_dir(), "jfk.wav"))
+            if (!empty(jfk)) {
+                var inscope hs <- create_session(m, "en")
+                heap_flat_leg(t, m, hs, jfk, "canary")
+            }
         }
         set_asr_kv(KVDtype.f16)   // back to the serving default
     }
@@ -1189,6 +1400,7 @@ def test_gemma4a_audio_oracle(t : T?) {
         with_dasllama_jobque_() {
             var inscope s <- create_session(m, "en")
             var inscope segs <- session_segs(m, s, samples)
+            heap_flat_leg(t, m, s, samples, "gemma4a")
             t |> equal(length(segs), 1, "one segment")
             to_log(LOG_INFO, "gemma4a eyeball: '{segs[0].text}'\n")
             // frozen llama-mtmd-cli no-think greedy ids (first 40 tokens — the confident prefix
diff --git a/modules/dasOPENAI/openai/openai_vision.das b/modules/dasOPENAI/openai/openai_vision.das
index d77fb85f58..a0386cf0e7 100644
--- a/modules/dasOPENAI/openai/openai_vision.das
+++ b/modules/dasOPENAI/openai/openai_vision.das
@@ -24,25 +24,36 @@ def private vision_image_part(image_url : string) : JsonValue? {
     return JV(tab)
 }
 
-def image_file_data_uri(path : string) : string {
-    //! The image file at ``path`` as the ``data:`` URL a browser would send (``image/png`` for a ``.png``
-    //! name, ``image/jpeg`` otherwise); "" for a file that cannot be read.
-    var bytes : array<uint8>
+def file_base64(path : string) : string {
+    //! The bytes of the file at ``path`` as base64 - a byte read, since an image or a clip carries interior NULs a
+    //! string read stops at; "" for a file that cannot be read.
+    var inscope bytes : array<uint8>
     fopen(path, "rb") $(f) {
         if (f != null) {
             bytes |> resize(int64(fstat(f).size))
             fread(f, bytes)
         }
     }
-    let uri = empty(bytes) ? "" : "data:image/{ends_with(to_lower(path), ".png") ? "png" : "jpeg"};base64,{base64_encode(bytes)}"
-    delete bytes
-    return uri
+    return empty(bytes) ? "" : base64_encode(bytes)
+}
+
+def image_file_data_uri(path : string) : string {
+    //! The image file at ``path`` as the ``data:`` URL a browser would send (``image/png`` for a ``.png``
+    //! name, ``image/jpeg`` otherwise); "" for a file that cannot be read.
+    let b64 = file_base64(path)
+    return empty(b64) ? "" : "data:image/{ends_with(to_lower(path), ".png") ? "png" : "jpeg"};base64,{b64}"
+}
+
+def private audio_part(audio_base64, format : string) : JsonValue? {
+    var inner <- { "data" => JV(audio_base64), "format" => JV(format) }
+    var tab <- { "type" => JV("input_audio"), "input_audio" => JV(inner) }
+    return JV(tab)
 }
 
-def vision_request_body(model, text, image_url : string; max_tokens : int = 300; system : string = "") : string {
-    //! Builds the JSON body for a one-shot vision request (a user turn with text + one image), under a
-    //! system message when ``system`` is not empty.
-    var content <- [vision_text_part(text), vision_image_part(image_url)]
+//! the JSON body of a one-shot request: a user turn of `text` and one media part, the media ahead of the text under
+//! `media_first`, under a system message when `system` is not empty
+def private media_request_body(model, text : string; var media : JsonValue?; max_tokens : int; system : string; media_first, no_think : bool) : string {
+    var content <- media_first ? [media, vision_text_part(text)] : [vision_text_part(text), media]
     var msg <- { "role" => JV("user"), "content" => JV(content) }
     var msgs : array<JsonValue?>
     if (!empty(system)) {
@@ -55,14 +66,41 @@ def vision_request_body(model, text, image_url : string; max_tokens : int = 300;
         "messages" => JV(msgs),
         "max_tokens" => JV(max_tokens)
     }
+    if (no_think) {   // both spellings: a server reads the flat field or the template's keyword arguments
+        var kwargs <- { "enable_thinking" => JV(false) }
+        body_tree["enable_thinking"] = JV(false)
+        body_tree["chat_template_kwargs"] = JV(kwargs)
+    }
     return write_json_compact(JV(body_tree))
 }
 
-def chat_vision(client : OpenAIClient; model, text, image_url : string; max_tokens : int = 300; system : string = "") : ChatResult {
+def vision_request_body(model, text, image_url : string; max_tokens : int = 300; system : string = ""; image_first : bool = false; no_think : bool = false) : string {
+    //! Builds the JSON body for a one-shot vision request (a user turn with text + one image, the image ahead of
+    //! the text under ``image_first``), under a system message when ``system`` is not empty; ``no_think`` asks a
+    //! thinking model to answer directly.
+    return media_request_body(model, text, vision_image_part(image_url), max_tokens, system, image_first, no_think)
+}
+
+def audio_request_body(model, text, audio_base64 : string; max_tokens : int = 300; system : string = ""; audio_first : bool = false; format : string = "wav"; no_think : bool = false) : string {
+    //! Builds the JSON body for a one-shot audio request: a user turn with text + one ``input_audio`` part carrying
+    //! the base64 of an audio file, the clip ahead of the text under ``audio_first``.
+    return media_request_body(model, text, audio_part(audio_base64, format), max_tokens, system, audio_first, no_think)
+}
+
+def chat_audio(client : OpenAIClient; model, text, audio_base64 : string; max_tokens : int = 300; system : string = ""; audio_first : bool = false; no_think : bool = false) : ChatResult {
+    //! One-shot audio request: a single user turn with text plus an audio clip (the base64 of its file).
+    //! Returns the normal chat result (assistant text in choices[0].message.content).
+    var response : ChatCompletionResponse
+    let err = post_and_decode(client, "/chat/completions",
+        audio_request_body(model, text, audio_base64, max_tokens, system, audio_first, "wav", no_think), response)
+    return ChatResult(ok = empty(err.kind), response <- response, error = err)
+}
+
+def chat_vision(client : OpenAIClient; model, text, image_url : string; max_tokens : int = 300; system : string = ""; image_first : bool = false; no_think : bool = false) : ChatResult {
     //! One-shot vision request: a single user turn with text plus an image (http(s) URL or
     //! a ``data:`` URL). Returns the normal chat result (assistant text in choices[0].message.content).
     var response : ChatCompletionResponse
     let err = post_and_decode(client, "/chat/completions",
-        vision_request_body(model, text, image_url, max_tokens, system), response)
+        vision_request_body(model, text, image_url, max_tokens, system, image_first, no_think), response)
     return ChatResult(ok = empty(err.kind), response <- response, error = err)
 }
diff --git a/modules/dasOPENAI/tests/test_vision.das b/modules/dasOPENAI/tests/test_vision.das
index e2412cf4da..ed802c9ac3 100644
--- a/modules/dasOPENAI/tests/test_vision.das
+++ b/modules/dasOPENAI/tests/test_vision.das
@@ -22,6 +22,15 @@ def test_vision_body_serialization(t : T?) {
         t |> success(find(body, "\"system\"") < 0, "no system message unless one is given")
         let under = vision_request_body("m", "What is this?", "https://example.com/x.png", 8, "Be brief.")
         t |> success(find(under, "\"role\": \"system\"") >= 0 && find(under, "Be brief.") < find(under, "What is this?"), "the system message leads: {under}")
+        t |> success(find(body, "What is this?") < find(body, "image_url"), "the text leads the image by default")
+        let first = vision_request_body("m", "What is this?", "https://example.com/x.png", 8, "", true)
+        t |> success(find(first, "image_url") < find(first, "What is this?"), "the image leads under image_first")
+        let heard = audio_request_body("m", "What is said?", "QUJD", 8, "", true)
+        t |> success(find(heard, "input_audio") >= 0 && find(heard, "QUJD") >= 0 && find(heard, "\"format\": \"wav\"") >= 0, "an audio body carries the clip as an input_audio part: {heard}")
+        t |> success(find(heard, "input_audio") < find(heard, "What is said?"), "the clip leads under audio_first")
+        t |> success(find(body, "enable_thinking") < 0, "no thinking field unless asked")
+        let quiet = vision_request_body("m", "What is this?", "https://example.com/x.png", 8, "", false, true)
+        t |> success(find(quiet, "\"enable_thinking\": false") >= 0 && find(quiet, "chat_template_kwargs") >= 0, "no_think sends both spellings: {quiet}")
     }
 }
 
diff --git a/site/files/dasllama/bench_cells.json b/site/files/dasllama/bench_cells.json
index 69ab75354b..3dc45a158a 100644
--- a/site/files/dasllama/bench_cells.json
+++ b/site/files/dasllama/bench_cells.json
@@ -973,46 +973,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":116.57599999999999
-          },
-          "img:pp":{
-            "tok_s":1349.2708747772838
-          },
-          "img:tg":{
-            "tok_s":84.976688061908348
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf"
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg"
-          }
-        ]
-      },
       {
         "engine":"llama.cpp",
         "backend":"metal",
@@ -1207,65 +1167,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":556.13199999999995,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":1523.7439999999999,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":10201.476000000001,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":13664.558000000001,
-            "audio_s":273.28724999999997
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"metal",
@@ -1449,46 +1350,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":37.496000000000002
-          },
-          "img:pp":{
-            "tok_s":5775.8524936132399
-          },
-          "img:tg":{
-            "tok_s":153.81460213289583
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"027907cc8",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf"
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg"
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"cpu",
@@ -1607,65 +1468,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":232.15100000000001,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":626.00599999999997,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":4283.308,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":5509.0820000000003,
-            "audio_s":273.28724999999997
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -6279,46 +6081,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":116.96899999999999
-          },
-          "img:pp":{
-            "tok_s":686.95533469256543
-          },
-          "img:tg":{
-            "tok_s":45.489373255944535
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E4B-it-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E4B-it-BF16.gguf"
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg"
-          }
-        ]
-      },
       {
         "engine":"llama.cpp",
         "backend":"metal",
@@ -6576,7 +6338,7 @@
       },
       {
         "engine":"das",
-        "backend":"metal",
+        "backend":"cpu",
         "flavor":"tuned",
         "box":"m5",
         "threads":6,
@@ -6585,39 +6347,30 @@
           "cpu":"Apple M5 Max"
         },
         "tests":{
-          "img:enc":{
-            "ms":38.258000000000003
+          "pp512":{
+            "tok_s":198.98778816603379
           },
-          "img:pp":{
-            "tok_s":3469.7508896797153
+          "tg128":{
+            "tok_s":53.652437013162661
           },
-          "img:tg":{
-            "tok_s":88.238619286204724
+          "tg128@4":{
+            "tok_s":126.09477403103192
           }
         },
-        "workload":"image-chat",
         "source":"official",
-        "sha":"027907cc8",
+        "sha":"9c5f93d3e",
         "version":"0.6.4",
         "files":[
           {
             "role":"weights",
             "name":"gemma-4-E4B-it-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E4B-it-BF16.gguf"
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg"
           }
         ]
       },
       {
-        "engine":"das",
+        "engine":"llama.cpp",
         "backend":"cpu",
-        "flavor":"tuned",
+        "flavor":"clean-cpu",
         "box":"m5",
         "threads":6,
         "date":"2026-09-22",
@@ -6626,48 +6379,17 @@
         },
         "tests":{
           "pp512":{
-            "tok_s":198.98778816603379
+            "tok_s":138.85149100000001
           },
           "tg128":{
-            "tok_s":53.652437013162661
+            "tok_s":38.231288999999997
           },
           "tg128@4":{
-            "tok_s":126.09477403103192
+            "tok_s":84.693333943684891
           }
         },
         "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E4B-it-Q8_0.gguf"
-          }
-        ]
-      },
-      {
-        "engine":"llama.cpp",
-        "backend":"cpu",
-        "flavor":"clean-cpu",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "pp512":{
-            "tok_s":138.85149100000001
-          },
-          "tg128":{
-            "tok_s":38.231288999999997
-          },
-          "tg128@4":{
-            "tok_s":84.693333943684891
-          }
-        },
-        "source":"official",
-        "sha":"6fdd0ac89",
+        "sha":"6fdd0ac89",
         "files":[
           {
             "role":"weights",
@@ -16148,69 +15870,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":42.091000000000001,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":101.517,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":532.49699999999996,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":675.56200000000001,
-            "audio_s":273.28724999999997
-          },
-          "asr:hp0x2.wav":{
-            "ms":1336.0650000000001,
-            "audio_s":546.57449999999994
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-tiny.bin"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"metal",
@@ -16393,69 +16052,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":34.768999999999998,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":86.671000000000006,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":508.22500000000002,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":571.58399999999995,
-            "audio_s":273.28724999999997
-          },
-          "asr:hp0x2.wav":{
-            "ms":1164.951,
-            "audio_s":546.57449999999994
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-tiny.bin"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"cpu",
@@ -17421,69 +17017,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":504.94,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":1063.703,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":4575.576,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":6574.8400000000001,
-            "audio_s":273.28724999999997
-          },
-          "asr:hp0x2.wav":{
-            "ms":12653.338,
-            "audio_s":546.57449999999994
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-large-v3-turbo.bin"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"metal",
@@ -17667,9 +17200,9 @@
         ]
       },
       {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
+        "engine":"whisper-cli",
+        "backend":"cpu",
+        "flavor":"stock",
         "box":"m5",
         "threads":6,
         "date":"2026-09-23",
@@ -17678,34 +17211,27 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":139.648,
-            "audio_s":11
+            "ms":2116.3000000000002
           },
           "asr:jfk3.wav":{
-            "ms":311.93599999999998,
-            "audio_s":33
+            "ms":4403.7599999999993
           },
           "asr:gb1.wav":{
-            "ms":1468.098,
-            "audio_s":198.734375
+            "ms":21943.809999999998
           },
           "asr:hp0.wav":{
-            "ms":1999.721,
-            "audio_s":273.28724999999997
+            "ms":28030.900000000001
           },
           "asr:hp0x2.wav":{
-            "ms":3860.2979999999998,
-            "audio_s":546.57449999999994
+            "ms":60482.059999999998
           }
         },
         "workload":"asr",
         "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
         "files":[
           {
             "role":"weights",
-            "name":"ggml-large-v3-turbo.bin"
+            "name":"ggml-large-v3-turbo-q8_0.bin"
           },
           {
             "role":"clip",
@@ -17731,7 +17257,7 @@
       },
       {
         "engine":"whisper-cli",
-        "backend":"cpu",
+        "backend":"metal",
         "flavor":"stock",
         "box":"m5",
         "threads":6,
@@ -17741,19 +17267,19 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":2116.3000000000002
+            "ms":153.38000000000002
           },
           "asr:jfk3.wav":{
-            "ms":4403.7599999999993
+            "ms":328.41000000000003
           },
           "asr:gb1.wav":{
-            "ms":21943.809999999998
+            "ms":1843.9200000000001
           },
           "asr:hp0.wav":{
-            "ms":28030.900000000001
+            "ms":2701.4200000000001
           },
           "asr:hp0x2.wav":{
-            "ms":60482.059999999998
+            "ms":5180.6999999999998
           }
         },
         "workload":"asr",
@@ -17786,8 +17312,8 @@
         ]
       },
       {
-        "engine":"whisper-cli",
-        "backend":"metal",
+        "engine":"onnx",
+        "backend":"cpu",
         "flavor":"stock",
         "box":"m5",
         "threads":6,
@@ -17797,64 +17323,8 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":153.38000000000002
-          },
-          "asr:jfk3.wav":{
-            "ms":328.41000000000003
-          },
-          "asr:gb1.wav":{
-            "ms":1843.9200000000001
-          },
-          "asr:hp0.wav":{
-            "ms":2701.4200000000001
-          },
-          "asr:hp0x2.wav":{
-            "ms":5180.6999999999998
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-large-v3-turbo-q8_0.bin"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
-      {
-        "engine":"onnx",
-        "backend":"cpu",
-        "flavor":"stock",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":1946.482,
-            "audio_s":11
+            "ms":1946.482,
+            "audio_s":11
           }
         },
         "workload":"asr",
@@ -18322,73 +17792,6 @@
         "comment":"On jfk.wav the reference's decode phase runs away (41.7 s of generation vs 30 ms on jfk3.wav; reproduced 3x with --temp 0 --reasoning off) - the two engines emit different amounts of text there, so that clip's ratio is a behavior difference, not a speed measurement.",
         "void_clips":"jfk.wav"
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":400.69200000000001,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":482.27499999999998,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":6080.7200000000003,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":8007.5699999999997,
-            "audio_s":273.28724999999997
-          },
-          "asr:hp0x2.wav":{
-            "ms":21452.121999999999,
-            "audio_s":546.57449999999994
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-Omni-30B-A3B-Instruct-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-Omni-30B-A3B-Instruct-bf16.gguf"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -19166,73 +18569,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":197.761,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":527.50599999999997,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":4049.2089999999998,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":5593.7709999999997,
-            "audio_s":273.28724999999997
-          },
-          "asr:hp0x2.wav":{
-            "ms":14705.468999999999,
-            "audio_s":546.57449999999994
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-ASR-0.6B-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-ASR-0.6B-bf16.gguf"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -19279,73 +18615,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":105.40000000000001,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":286.846,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":1979.1700000000001,
-            "audio_s":198.734375
-          },
-          "asr:hp0.wav":{
-            "ms":2723.636,
-            "audio_s":273.28724999999997
-          },
-          "asr:hp0x2.wav":{
-            "ms":7310.8400000000001,
-            "audio_s":546.57449999999994
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-ASR-0.6B-Q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-ASR-0.6B-bf16.gguf"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav"
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav"
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -19727,57 +18996,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M4 Pro"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":502.17599999999999,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":1532.3140000000001,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":11932.397999999999,
-            "audio_s":198.734375
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"canary-qwen-2.5b-decoder-q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"canary-qwen-2.5b-encoder-f32.bin"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          }
-        ]
-      },
       {
         "engine":"nemo",
         "backend":"cpu",
@@ -19860,57 +19078,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "hardware":{
-          "cpu":"Apple M5 Max"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":321.988,
-            "audio_s":11
-          },
-          "asr:jfk3.wav":{
-            "ms":892.68399999999997,
-            "audio_s":33
-          },
-          "asr:gb1.wav":{
-            "ms":6502.0730000000003,
-            "audio_s":198.734375
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "files":[
-          {
-            "role":"weights",
-            "name":"canary-qwen-2.5b-decoder-q8_0.gguf"
-          },
-          {
-            "role":"mmproj",
-            "name":"canary-qwen-2.5b-encoder-f32.bin"
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav"
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav"
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav"
-          }
-        ]
-      },
       {
         "engine":"nemo",
         "backend":"cpu",
diff --git a/site/files/dasllama/bench_records.json b/site/files/dasllama/bench_records.json
index f8b570dc02..1b87bf66ca 100644
--- a/site/files/dasllama/bench_records.json
+++ b/site/files/dasllama/bench_records.json
@@ -1532,70 +1532,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/models/gemma-4-E2B-it-Q8_0.gguf --image-mmproj ~/models/mmproj-gemma-4-E2B-it-bf16.gguf --image ~/models/coco-val2017-000000039769.jpg -r 3 -t 10 -o json --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":116.57599999999999
-          },
-          "img:pp":{
-            "tok_s":1349.2708747772838
-          },
-          "img:tg":{
-            "tok_s":84.976688061908348,
-            "text":": This is an image of two tabby cats lying on a pink surface."
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"llama.cpp",
         "backend":"metal",
@@ -1889,101 +1825,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m gemma-4-E2B-it-Q8_0.gguf -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":556.13199999999995,
-            "audio_s":11,
-            "encode_ms":58.156999999999996,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":1523.7439999999999,
-            "audio_s":33,
-            "encode_ms":164.203,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:gb1.wav":{
-            "ms":10201.476000000001,
-            "audio_s":198.734375,
-            "encode_ms":916.78800000000001,
-            "text":"Fellow Americans, this day has brought terrible news and great sadness to our country. At 9:00 this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kulpna Shawla, and Elaine Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity in an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce atmosphere of the Earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens, who created space, he who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families and may God may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":13664.558000000001,
-            "audio_s":273.28724999999997,
-            "encode_ms":1272.1220000000001,
-            "text":"Henry F. Phillips from Wikipedia, the free encyclopedia at en.wikipedia.org. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips major contribution was in driving the crosshead concept forward to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, US patent number 2,46343, US patents 2,46837 to 2,46840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screwmakers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips screw company and the American Screw Company went on to devise the Pozidrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption: Phillips screw head. The following is an infobox which accompanies this article. Infobox: Part of the series on screw drive types. Slotted, commonly erroneously flathead, Phillips, crosshead, Pozidrive, superdrive, torques, hex, Allen, Robertson, triwing, torque set, spanner head, triple square, XZN, others, polydrive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the 9th of April, 2008 at 17:04. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a US registered 501(c)3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/copyleft/fdl.html."
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"metal",
@@ -2278,70 +2119,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf --image-mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E2B-it-bf16.gguf --image ~/Work/llama.cpp/models/coco-val2017-000000039769.jpg -r 3 -t 6 -o json --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":37.496000000000002
-          },
-          "img:pp":{
-            "tok_s":5775.8524936132399
-          },
-          "img:tg":{
-            "tok_s":153.81460213289583,
-            "text":": This is an image of two tabby cats lying on a pink surface."
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"027907cc8",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"cpu",
@@ -2526,13 +2303,13 @@
         ]
       },
       {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
+        "engine":"llama-mtmd-cli",
+        "backend":"cpu",
+        "flavor":"stock",
         "box":"m5",
         "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m gemma-4-E2B-it-Q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
+        "date":"2026-09-22",
+        "cmd":"../llama.cpp-mtmd-ref/build-cpu/bin/llama-mtmd-cli -m ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf --mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E2B-it-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 0 -t 6",
         "hardware":{
           "cpu":"Apple M5 Max",
           "arch":"arm64",
@@ -2546,41 +2323,25 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":232.15100000000001,
-            "audio_s":11,
-            "encode_ms":34.542000000000002,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":7641.5,
+            "encode_ms":7274.6999999999998,
+            "text":"0.00.001.820 I common_init_result: fitting params to device memory ... 0.00.001.822 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.239.661 I common_params_fit_impl: projected to use 4889 MiB of host memory vs. 131072 MiB of total host memory 0.00.431.813 W load: control-looking token:     50 '<|tool_response>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.433.564 W load: control-looking token:    212 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.438.463 W load: special_eog_ids contains '<|tool_response>', removing '</s>' token from EOG list 0.01.672.459 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.01.713.201 I mtmd_cli_context: chat template example: <|turn>system You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model 0.01.883.404 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.01.883.451 I main: loading model: ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf 0.01.883.589 W WARN: This is an experimental CLI for testing multimodal capability. 0.01.883.590 W       For normal use cases, please use the standard llama-cli 0.01.912.829 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 3) 0.08.380.144 I mtmd batch encoding done in 6467 ms And so my fellow Americans ask not what your country can do for you ask what you can do for your country.DASLLAMA_IDS: 3133 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 236761 106"
           },
           "asr:jfk3.wav":{
-            "ms":626.00599999999997,
-            "audio_s":33,
-            "encode_ms":96.992999999999995,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country"
+            "ms":22989.599999999999,
+            "encode_ms":21870.299999999999,
+            "text":"0.00.001.769 I common_init_result: fitting params to device memory ... 0.00.001.770 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.239.363 I common_params_fit_impl: projected to use 4889 MiB of host memory vs. 131072 MiB of total host memory 0.00.432.921 W load: control-looking token:     50 '<|tool_response>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.434.765 W load: control-looking token:    212 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.439.840 W load: special_eog_ids contains '<|tool_response>', removing '</s>' token from EOG list 0.01.665.594 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.01.704.947 I mtmd_cli_context: chat template example: <|turn>system You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model 0.01.872.265 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.01.872.309 I main: loading model: ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf 0.01.872.414 W WARN: This is an experimental CLI for testing multimodal capability. 0.01.872.415 W       For normal use cases, please use the standard llama-cli 0.01.907.044 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 4) 0.19.532.739 I mtmd batch encoding done in 17626 ms 0.21.614.368 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 4) 0.23.405.537 I mtmd batch encoding done in 1792 ms And so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country.DASLLAMA_IDS: 3133 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 532 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 532 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 236761 106"
           },
           "asr:gb1.wav":{
-            "ms":4283.308,
-            "audio_s":198.734375,
-            "encode_ms":539.28200000000004,
-            "text":"Fellow Americans, this day has brought terrible news and great sadness to our country. At 9:00 this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kulpna Shawla, and Elaine Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity in an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce atmosphere of the Earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens, who created space, he who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families and may God may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":5509.0820000000003,
-            "audio_s":273.28724999999997,
-            "encode_ms":784.60400000000004,
-            "text":"Henry F. Phillips from Wikipedia, the free encyclopedia at en.wikipedia.org. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips major contribution was in driving the crosshead concept forward to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, US patent number 2,46343, US patents 2,46837 to 2,46840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screwmakers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips screw company and the American Screw Company went on to devise the Pozidrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption: Phillips screw head. The following is an infobox which accompanies this article. Infobox: Part of the series on screw drive types. Slotted, commonly erroneously flathead, Phillips, crosshead, Pozidrive, superdrive, torques, hex, Allen, Robertson, triwing, torque set, spanner head, triple square, XZN, others, polydrive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the 9th of April, 2008 at 17:04. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a US registered 501(c)3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/copyleft/fdl.html."
+            "ms":143038.89999999999,
+            "encode_ms":134953.89999999999,
+            "text":"0.00.001.779 I common_init_result: fitting params to device memory ... 0.00.001.782 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.237.528 I common_params_fit_impl: projected to use 4889 MiB of host memory vs. 131072 MiB of total host memory 0.00.429.154 W load: control-looking token:     50 '<|tool_response>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.430.985 W load: control-looking token:    212 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.435.922 W load: special_eog_ids contains '<|tool_response>', removing '</s>' token from EOG list 0.01.662.980 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.01.703.088 I mtmd_cli_context: chat template example: <|turn>system You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model 0.01.871.875 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.01.871.924 I main: loading model: ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf 0.01.872.076 W WARN: This is an experimental CLI for testing multimodal capability. 0.01.872.077 W       For normal use cases, please use the standard llama-cli 0.01.953.888 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 9) 0.19.578.870 I mtmd batch encoding done in 17624 ms 0.21.651.449 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 9) 0.39.266.049 I mtmd batch encoding done in 17615 ms 0.41.637.811 I encoding mtmd batch, n_chunks = 1 (done = 3, total = 9) 0.59.254.238 I mtmd batch encoding done in 17617 ms 1.01.835.307 I encoding mtmd batch, n_chunks = 1 (done = 4, total = 9) 1.19.466.818 I mtmd batch encoding done in 17631 ms 1.22.254.846 I encoding mtmd batch, n_chunks = 1 (done = 5, total = 9) 1.39.848.156 I mtmd batch encoding done in 17594 ms 1.42.852.483 I encoding mtmd batch, n_chunks = 1 (done = 6, total = 9) 2.00.456.414 I mtmd batch encoding done in 17604 ms 2.03.682.115 I encoding mtmd batch, n_chunks = 1 (done = 7, total = 9) 2.14.684.780 I mtmd batch encoding done in 11002 ms My fellow Americans, this day has brought terrible news and great sadness to our country. At 9:00 this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kulpna Shawla, and Elaine Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity in an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce atmosphere of the Earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. As far as we can see, there is comfort and hope in the words of the prophet Isaiah. Lift your eyes and look to the heavens, who created space. He who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the Shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families and may God may God continue to bless America.DASLLAMA_IDS: 4754 12339 14522 236764 672 1719 815 6111 21832 4668 532 1822 55882 531 1023 2891 236761 2640 236743 236819 236787 236771 236771 672 5597 236764 9017 2256 528 21912 5745 3662 607 1023 2557 51320 18693 236761 562 2822 990 3209 236764 37061 691 3472 14773 699 506 55748 2787 9539 236761 669 18693 563 5745 236761 2085 659 951 43732 236761 2154 3905 691 496 13919 529 6819 236787 44221 26839 89702 236764 41523 44221 8972 19864 236764 43224 94816 18093 236764 22359 6822 9833 236764 43224 8966 16376 1209 236764 3587 236761 751 19321 1789 34525 2149 236764 532 98134 121873 236764 496 105721 528 506 33722 5661 15150 236761 3143 1758 532 3607 12718 1822 4652 528 506 2509 531 784 27069 528 614 3911 1056 2557 10224 815 2229 531 4483 4180 15668 236761 1030 563 3735 531 29346 506 39793 529 4301 684 35305 532 506 18502 529 67112 506 48621 11661 529 506 10824 236761 3143 101195 7261 506 39793 532 901 17175 1091 95826 236764 14111 901 1053 496 1494 532 29417 5708 528 1972 236761 8468 529 910 23648 532 63485 532 184291 236764 692 795 4305 1091 784 506 919 236761 2343 14522 3124 659 6972 618 1388 529 506 7965 529 1239 1758 532 3607 1015 735 1010 2238 672 11059 10932 532 32717 236761 1599 236789 500 711 7057 236761 5137 4251 7097 66031 2061 607 611 236761 1452 1724 611 9312 795 2462 735 506 2833 532 36637 529 672 2891 236761 669 4400 528 837 901 8390 795 4102 236761 192411 563 5378 1131 506 29151 6998 1023 1902 684 506 18014 529 17324 532 506 86508 531 3050 236761 5137 9338 1131 2557 795 817 580 236761 799 506 55748 3124 236764 692 5004 21404 532 40578 236761 1773 2793 618 692 740 1460 236764 993 563 5931 532 4614 528 506 4171 529 506 59918 81034 236761 79493 822 6114 532 1385 531 506 80958 236764 1015 4464 2557 236761 1293 1015 12076 855 506 129196 20472 886 684 886 532 9139 1091 1546 684 1463 236761 8468 529 914 1822 2066 532 45478 6332 236764 711 886 529 1091 563 9724 236761 669 1638 33797 1015 5618 506 8197 992 10077 506 5618 529 506 6819 39690 692 92377 3124 236761 669 13919 529 506 114357 18693 1602 711 994 21236 531 10824 236761 16961 692 740 14098 600 784 659 21236 2033 236761 3353 3803 14321 506 112792 7965 532 1149 3803 1149 3803 4102 531 14321 5711 236761 106"
           }
         },
         "workload":"audio-chat",
         "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
+        "versions":"llama.cpp @ ebd048fc5 + mtmd-timing.patch@8026b1bd",
+        "exec_fmt":"bf16/q8_0",
         "files":[
           {
             "role":"weights",
@@ -2611,96 +2372,17 @@
             "name":"gb1.wav",
             "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
             "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
           }
         ]
       },
       {
         "engine":"llama-mtmd-cli",
-        "backend":"cpu",
+        "backend":"metal",
         "flavor":"stock",
         "box":"m5",
         "threads":6,
         "date":"2026-09-22",
-        "cmd":"../llama.cpp-mtmd-ref/build-cpu/bin/llama-mtmd-cli -m ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf --mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E2B-it-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 0 -t 6",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":7641.5,
-            "encode_ms":7274.6999999999998,
-            "text":"0.00.001.820 I common_init_result: fitting params to device memory ... 0.00.001.822 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.239.661 I common_params_fit_impl: projected to use 4889 MiB of host memory vs. 131072 MiB of total host memory 0.00.431.813 W load: control-looking token:     50 '<|tool_response>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.433.564 W load: control-looking token:    212 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.438.463 W load: special_eog_ids contains '<|tool_response>', removing '</s>' token from EOG list 0.01.672.459 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.01.713.201 I mtmd_cli_context: chat template example: <|turn>system You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model 0.01.883.404 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.01.883.451 I main: loading model: ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf 0.01.883.589 W WARN: This is an experimental CLI for testing multimodal capability. 0.01.883.590 W       For normal use cases, please use the standard llama-cli 0.01.912.829 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 3) 0.08.380.144 I mtmd batch encoding done in 6467 ms And so my fellow Americans ask not what your country can do for you ask what you can do for your country.DASLLAMA_IDS: 3133 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 236761 106"
-          },
-          "asr:jfk3.wav":{
-            "ms":22989.599999999999,
-            "encode_ms":21870.299999999999,
-            "text":"0.00.001.769 I common_init_result: fitting params to device memory ... 0.00.001.770 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.239.363 I common_params_fit_impl: projected to use 4889 MiB of host memory vs. 131072 MiB of total host memory 0.00.432.921 W load: control-looking token:     50 '<|tool_response>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.434.765 W load: control-looking token:    212 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.439.840 W load: special_eog_ids contains '<|tool_response>', removing '</s>' token from EOG list 0.01.665.594 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.01.704.947 I mtmd_cli_context: chat template example: <|turn>system You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model 0.01.872.265 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.01.872.309 I main: loading model: ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf 0.01.872.414 W WARN: This is an experimental CLI for testing multimodal capability. 0.01.872.415 W       For normal use cases, please use the standard llama-cli 0.01.907.044 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 4) 0.19.532.739 I mtmd batch encoding done in 17626 ms 0.21.614.368 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 4) 0.23.405.537 I mtmd batch encoding done in 1792 ms And so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country and so my fellow Americans ask not what your country can do for you ask what you can do for your country.DASLLAMA_IDS: 3133 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 532 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 532 834 1041 12339 14522 2679 711 1144 822 2891 740 776 573 611 2679 1144 611 740 776 573 822 2891 236761 106"
-          },
-          "asr:gb1.wav":{
-            "ms":143038.89999999999,
-            "encode_ms":134953.89999999999,
-            "text":"0.00.001.779 I common_init_result: fitting params to device memory ... 0.00.001.782 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.237.528 I common_params_fit_impl: projected to use 4889 MiB of host memory vs. 131072 MiB of total host memory 0.00.429.154 W load: control-looking token:     50 '<|tool_response>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.430.985 W load: control-looking token:    212 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.435.922 W load: special_eog_ids contains '<|tool_response>', removing '</s>' token from EOG list 0.01.662.980 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.01.703.088 I mtmd_cli_context: chat template example: <|turn>system You are a helpful assistant<turn|> <|turn>user Hello<turn|> <|turn>model Hi there<turn|> <|turn>user How are you?<turn|> <|turn>model 0.01.871.875 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.01.871.924 I main: loading model: ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf 0.01.872.076 W WARN: This is an experimental CLI for testing multimodal capability. 0.01.872.077 W       For normal use cases, please use the standard llama-cli 0.01.953.888 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 9) 0.19.578.870 I mtmd batch encoding done in 17624 ms 0.21.651.449 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 9) 0.39.266.049 I mtmd batch encoding done in 17615 ms 0.41.637.811 I encoding mtmd batch, n_chunks = 1 (done = 3, total = 9) 0.59.254.238 I mtmd batch encoding done in 17617 ms 1.01.835.307 I encoding mtmd batch, n_chunks = 1 (done = 4, total = 9) 1.19.466.818 I mtmd batch encoding done in 17631 ms 1.22.254.846 I encoding mtmd batch, n_chunks = 1 (done = 5, total = 9) 1.39.848.156 I mtmd batch encoding done in 17594 ms 1.42.852.483 I encoding mtmd batch, n_chunks = 1 (done = 6, total = 9) 2.00.456.414 I mtmd batch encoding done in 17604 ms 2.03.682.115 I encoding mtmd batch, n_chunks = 1 (done = 7, total = 9) 2.14.684.780 I mtmd batch encoding done in 11002 ms My fellow Americans, this day has brought terrible news and great sadness to our country. At 9:00 this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kulpna Shawla, and Elaine Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity in an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce atmosphere of the Earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. As far as we can see, there is comfort and hope in the words of the prophet Isaiah. Lift your eyes and look to the heavens, who created space. He who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the Shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families and may God may God continue to bless America.DASLLAMA_IDS: 4754 12339 14522 236764 672 1719 815 6111 21832 4668 532 1822 55882 531 1023 2891 236761 2640 236743 236819 236787 236771 236771 672 5597 236764 9017 2256 528 21912 5745 3662 607 1023 2557 51320 18693 236761 562 2822 990 3209 236764 37061 691 3472 14773 699 506 55748 2787 9539 236761 669 18693 563 5745 236761 2085 659 951 43732 236761 2154 3905 691 496 13919 529 6819 236787 44221 26839 89702 236764 41523 44221 8972 19864 236764 43224 94816 18093 236764 22359 6822 9833 236764 43224 8966 16376 1209 236764 3587 236761 751 19321 1789 34525 2149 236764 532 98134 121873 236764 496 105721 528 506 33722 5661 15150 236761 3143 1758 532 3607 12718 1822 4652 528 506 2509 531 784 27069 528 614 3911 1056 2557 10224 815 2229 531 4483 4180 15668 236761 1030 563 3735 531 29346 506 39793 529 4301 684 35305 532 506 18502 529 67112 506 48621 11661 529 506 10824 236761 3143 101195 7261 506 39793 532 901 17175 1091 95826 236764 14111 901 1053 496 1494 532 29417 5708 528 1972 236761 8468 529 910 23648 532 63485 532 184291 236764 692 795 4305 1091 784 506 919 236761 2343 14522 3124 659 6972 618 1388 529 506 7965 529 1239 1758 532 3607 1015 735 1010 2238 672 11059 10932 532 32717 236761 1599 236789 500 711 7057 236761 5137 4251 7097 66031 2061 607 611 236761 1452 1724 611 9312 795 2462 735 506 2833 532 36637 529 672 2891 236761 669 4400 528 837 901 8390 795 4102 236761 192411 563 5378 1131 506 29151 6998 1023 1902 684 506 18014 529 17324 532 506 86508 531 3050 236761 5137 9338 1131 2557 795 817 580 236761 799 506 55748 3124 236764 692 5004 21404 532 40578 236761 1773 2793 618 692 740 1460 236764 993 563 5931 532 4614 528 506 4171 529 506 59918 81034 236761 79493 822 6114 532 1385 531 506 80958 236764 1015 4464 2557 236761 1293 1015 12076 855 506 129196 20472 886 684 886 532 9139 1091 1546 684 1463 236761 8468 529 914 1822 2066 532 45478 6332 236764 711 886 529 1091 563 9724 236761 669 1638 33797 1015 5618 506 8197 992 10077 506 5618 529 506 6819 39690 692 92377 3124 236761 669 13919 529 506 114357 18693 1602 711 994 21236 531 10824 236761 16961 692 740 14098 600 784 659 21236 2033 236761 3353 3803 14321 506 112792 7965 532 1149 3803 1149 3803 4102 531 14321 5711 236761 106"
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "versions":"llama.cpp @ ebd048fc5 + mtmd-timing.patch@8026b1bd",
-        "exec_fmt":"bf16/q8_0",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E2B-it-Q8_0.gguf",
-            "sha256":"996d08777aadc6bfd3c7375ef70ba25a0f55240075860754fdb18d6d860aa63a",
-            "bytes":4967497152
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E2B-it-bf16.gguf",
-            "sha256":"711e1e8f43fa0664adbac493129be1e6c25b81af4b4cdea97c7d798b25c0a3a4",
-            "bytes":986833664
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          }
-        ]
-      },
-      {
-        "engine":"llama-mtmd-cli",
-        "backend":"metal",
-        "flavor":"stock",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "cmd":"../llama.cpp-mtmd-ref/build-metal/bin/llama-mtmd-cli -m ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf --mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E2B-it-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 99 -t 6",
+        "cmd":"../llama.cpp-mtmd-ref/build-metal/bin/llama-mtmd-cli -m ~/Work/llama.cpp/models/gemma-4-E2B-it-Q8_0.gguf --mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E2B-it-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 99 -t 6",
         "hardware":{
           "cpu":"Apple M5 Max",
           "arch":"arm64",
@@ -9773,70 +9455,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/models/gemma-4-E4B-it-Q8_0.gguf --image-mmproj ~/models/mmproj-gemma-4-E4B-it-BF16.gguf --image ~/models/coco-val2017-000000039769.jpg -r 3 -t 10 -o json --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":116.96899999999999
-          },
-          "img:pp":{
-            "tok_s":686.95533469256543
-          },
-          "img:tg":{
-            "tok_s":45.489373255944535,
-            "text":"The user wants a one-sentence description of the provided image.\nThe image contains two cats lying on a pink surface.\n\nPlan: Describe the main subjects"
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E4B-it-Q8_0.gguf",
-            "sha256":"34be82b17b4942d389b9b527170c4b058027abdd32531fda063d3d97dd8ce80a",
-            "bytes":8031242688
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E4B-it-BF16.gguf",
-            "sha256":"f77995e4b6a569ab8f0d1bfdb7e8da4a0fa5b9e6f309b9bf3bdb76164d75e29f",
-            "bytes":991552256
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"llama.cpp",
         "backend":"metal",
@@ -10228,70 +9846,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- -m ~/Work/llama.cpp/models/gemma-4-E4B-it-Q8_0.gguf --image-mmproj ~/Work/llama.cpp/models/mmproj-gemma-4-E4B-it-BF16.gguf --image ~/Work/llama.cpp/models/coco-val2017-000000039769.jpg -r 3 -t 6 -o json --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 99",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "img:enc":{
-            "ms":38.258000000000003
-          },
-          "img:pp":{
-            "tok_s":3469.7508896797153
-          },
-          "img:tg":{
-            "tok_s":88.238619286204724,
-            "text":"The user wants a one-sentence description of the provided image.\nThe image contains two cats lying on a pink surface.\n\nPlan: Describe the main subjects"
-          }
-        },
-        "workload":"image-chat",
-        "source":"official",
-        "sha":"027907cc8",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "parity":"ok",
-        "exec_fmt":"tower gemma4v f32; weights q8 native; q8 activations; f16 scales; metal blob",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"gemma-4-E4B-it-Q8_0.gguf",
-            "sha256":"34be82b17b4942d389b9b527170c4b058027abdd32531fda063d3d97dd8ce80a",
-            "bytes":8031242688
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-gemma-4-E4B-it-BF16.gguf",
-            "sha256":"f77995e4b6a569ab8f0d1bfdb7e8da4a0fa5b9e6f309b9bf3bdb76164d75e29f",
-            "bytes":991552256
-          },
-          {
-            "role":"image",
-            "name":"coco-val2017-000000039769.jpg",
-            "sha256":"dea9e7ef97386345f7cff32f9055da4982da5471c48d575146c796ab4563b04e",
-            "bytes":173131
-          }
-        ]
-      },
       {
         "engine":"das",
         "backend":"cpu",
@@ -24874,13 +24428,13 @@
         ]
       },
       {
-        "engine":"das",
+        "engine":"whisper-cli",
         "backend":"metal",
-        "flavor":"tuned",
+        "flavor":"stock",
         "box":"m4",
         "threads":10,
         "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-tiny.bin -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
+        "cmd":"~/whisper.cpp/build/bin/whisper-cli -m ~/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 10 -bs 1 -bo 1",
         "hardware":{
           "cpu":"Apple M4 Pro",
           "arch":"arm64",
@@ -24894,53 +24448,31 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":42.091000000000001,
-            "audio_s":11,
-            "encode_ms":22.661999999999999,
-            "text":" And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":51.330000000000005
           },
           "asr:jfk3.wav":{
-            "ms":101.517,
-            "audio_s":33,
-            "encode_ms":48.914999999999999,
-            "text":" And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":122.10999999999999
           },
           "asr:gb1.wav":{
-            "ms":532.49699999999996,
-            "audio_s":198.734375,
-            "encode_ms":213.96799999999999,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control and Houston lost contact with our Space Shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia's lost. There are no survivors. And board was a crew of seven, Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Cooltna Chavla, and Elon Ramon, a Colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the earth. These astronauts knew the dangers and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock in grief. You're not alone. Our entire nation agrees with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Man kind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. As farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens who created all these, He who brings out the story hosts one by one and calls them each by name, because of His great power and mighty strength, not one of them is missing. The same creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth yet we can pray that all are safely home. May God bless the grieving families and may God continue to bless America. [BLANK_AUDIO]"
+            "ms":683.98000000000002
           },
           "asr:hp0.wav":{
-            "ms":675.56200000000001,
-            "audio_s":273.28724999999997,
-            "encode_ms":270.67200000000003,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used power to screw drivers. Phillips Major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the Pawsadrive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompanied this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A U.S. registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html."
+            "ms":800.20999999999992
           },
           "asr:hp0x2.wav":{
-            "ms":1336.0650000000001,
-            "audio_s":546.57449999999994,
-            "encode_ms":584.16399999999999,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used power to screw drivers. Phillips Major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the Pawsadrive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompanied this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A U.S. registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html. Henry F Phillips from Wikipedia, the free The Korean Cyclopedia at EN. Wikipedia.org Henry F. Phillips From Wikipedia, the Korean Cyclopedia Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Philips' head screw and screwdriver named after him. The importance of the cross head screw design lies in its self-centering property, useful on automated production lines that use powered screw drivers. Philips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343, US patents 2,046,837 to 2,046,847 840. It was so widely copied that by 1949, Phillips lost his patent. The American screw company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw. As distinct from the simple mild slot of a slotted type screw. The Phillips screw company and the American screw company went on to devise the Pawsadrive screw which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article caption \"Philips Screwhead\". The following is an info box which accompanies this article. In a info box part of the series on screw drive types. Slaughted, commonly, erroneously, flat head. Phillips, cross head. Paws of Drive, Super Drive. Torx, Hex, Allen, Robertson, Tri-wing, Torxet, Spannerhead, Triple Square, XZN, Others, Polydrive, Spline Drive, Double Hacks, Many images accompanied this infobox. This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the Gnue-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Inc. A U.S. registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html."
+            "ms":1609.6300000000001
           }
         },
         "workload":"asr",
         "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
+        "versions":"whisper.cpp @ 6fc7c33b4",
+        "exec_fmt":"q8_0",
         "files":[
           {
             "role":"weights",
-            "name":"ggml-tiny.bin",
-            "sha256":"be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21",
-            "bytes":77691713
+            "name":"ggml-tiny-q8_0.bin",
+            "sha256":"c2085835d3f50733e2ff6e4b41ae8a2b8d8110461e18821b09a15c40c42d1cca",
+            "bytes":43537433
           },
           {
             "role":"clip",
@@ -24975,109 +24507,30 @@
         ]
       },
       {
-        "engine":"whisper-cli",
-        "backend":"metal",
-        "flavor":"stock",
-        "box":"m4",
-        "threads":10,
+        "engine":"das",
+        "backend":"cpu",
+        "flavor":"tuned",
+        "box":"m5",
+        "threads":6,
         "date":"2026-09-23",
-        "cmd":"~/whisper.cpp/build/bin/whisper-cli -m ~/models/ggml-tiny-q8_0.bin -f modules/dasLLAMA/benchmarks/asr/corpus/hp0x2.wav -t 10 -bs 1 -bo 1",
+        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-tiny.bin -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json",
         "hardware":{
-          "cpu":"Apple M4 Pro",
+          "cpu":"Apple M5 Max",
           "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
+          "os":"macOS 26.6.2",
+          "perf_cores":6,
+          "total_cores":18,
+          "ram_gb":128,
+          "gpu":"Apple M5 Max (40-core)",
+          "model_id":"Mac17,6",
           "remote_desktop":"off"
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":51.330000000000005
-          },
-          "asr:jfk3.wav":{
-            "ms":122.10999999999999
-          },
-          "asr:gb1.wav":{
-            "ms":683.98000000000002
-          },
-          "asr:hp0.wav":{
-            "ms":800.20999999999992
-          },
-          "asr:hp0x2.wav":{
-            "ms":1609.6300000000001
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "versions":"whisper.cpp @ 6fc7c33b4",
-        "exec_fmt":"q8_0",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-tiny-q8_0.bin",
-            "sha256":"c2085835d3f50733e2ff6e4b41ae8a2b8d8110461e18821b09a15c40c42d1cca",
-            "bytes":43537433
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
-      {
-        "engine":"das",
-        "backend":"cpu",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-tiny.bin -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":66.117000000000004,
-            "audio_s":11,
-            "encode_ms":46.429000000000002,
-            "text":" And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
+            "ms":66.117000000000004,
+            "audio_s":11,
+            "encode_ms":46.429000000000002,
+            "text":" And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
           },
           "asr:jfk3.wav":{
             "ms":149.26499999999999,
@@ -25255,107 +24708,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-tiny.bin -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":34.768999999999998,
-            "audio_s":11,
-            "encode_ms":18.687999999999999,
-            "text":" And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":86.671000000000006,
-            "audio_s":33,
-            "encode_ms":35.045000000000002,
-            "text":" And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":508.22500000000002,
-            "audio_s":198.734375,
-            "encode_ms":184.029,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control and Houston lost contact with our Space Shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia's lost. our no survivors. On board was a crew of seven, Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McHool, Dr. Kultner Chavla, and Elon Ramon, a Colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine. It is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the earth. These astronauts knew the dangers and they faced them willingly. knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock in grief. You're not alone. Our entire nation agrees with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. in the skies today, we saw destruction and tragedy. As farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, lift your eyes and look to the heavens, who created all these, he who brings out the story hosts one by one, and calls them each by name, because of his great power and mighty strength, not one of them is missing. The same creator who names the stars, also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families. and make out what may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":571.58399999999995,
-            "audio_s":273.28724999999997,
-            "encode_ms":202.53,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia, at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used powered screwdrivers. Phillips major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the positive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-Wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompany this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A US registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html."
-          },
-          "asr:hp0x2.wav":{
-            "ms":1164.951,
-            "audio_s":546.57449999999994,
-            "encode_ms":439.428,
-            "text":" Henry F. Phillips from Wikipedia, the Free Encyclopedia, at EN.Wikipedia.org. Henry F. Phillips from Wikipedia, the Free Encyclopedia. Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Phillips-head screw and screwdriver named after him. The importance of the cross-head screw design lies in its self-centering property, useful on automated production lines that used powered screwdrivers. Phillips major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343,000 U.S. patents, 2,046,837 to 2,046,840. It was so widely copied that by 1949, Philips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw as distinct from the simple milled slot of a slotted type screw. The Philips screw company and the American screw company went on to devise the positive screw, which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article, caption, \"Philips screw head.\" The following is an info box which accompanies this article. Info box part of the series on screw drive types. Slotted commonly erroneously flat head. Phillips cross head. Positrive Super Drive. Torx. Alex Allen Robertson Tri-Wing Torxet Spannerhead Triple Square XZN Others Polydrive Spline Drive Double Hex Many images accompany this info box This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the GNU-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wiki media foundation incorporated. A US registered 501 C3 tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation license. Available at www.gnu.org/copyleft/fdl.html. Henry F Phillips from Wikipedia, the free The Korean Cyclopedia at EN. Wikipedia.org Henry F. Phillips From Wikipedia, the Korean Cyclopedia Henry F. Phillips, 1890 to 1958, a US businessman from Portland, Oregon, has the honor of having the Philips' head screw and screwdriver named after him. The importance of the cross head screw design lies in its self-centering property, useful on automated production lines that use powered screw drivers. Philips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, US patent number 2,046,343, US patents 2,046,837 to 2,046,847 840. It was so widely copied that by 1949, Phillips lost his patent. The American screw company was responsible for devising a means of manufacturing the screw and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw. As distinct from the simple mild slot of a slotted type screw. The Phillips screw company and the American screw company went on to devise the Pawsadrive screw which differs from the Philips in that it is designed to accommodate greater torque than the Philips. An image accompanied this article caption \"Philips Screwhead\". The following is an info box which accompanies this article. In the info box part of the series on screw drive types. Slaughted, commonly, erroneously, flat head. Phillips, cross head. Paws of Drive, Super Drive. Torx, Hex, Allen, Robertson, Tri-wing, Torxet, Spannerhead, Triple Square, XZN, Others, Polydrive, Spline Drive, Double Hex. Many images accompanied this info box. This page was last modified on 9 April 2008 at 1704. All text is available under the terms of the Gnue-free documentation license. See Copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Inc. a US registered 501c3 tax deductible nonprofit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License. Available at www.gnu.org/copyleft/fdl.a THTML"
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"5bb0cdbbe45233cc8ea5a048c6a9239940308c1dcce98291e1dd702421f3d3f8",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-tiny.bin",
-            "sha256":"be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21",
-            "bytes":77691713
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"cpu",
@@ -26796,107 +26148,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-large-v3-turbo.bin -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":504.94,
-            "audio_s":11,
-            "encode_ms":441.49099999999999,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":1063.703,
-            "audio_s":33,
-            "encode_ms":883.54100000000005,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":4575.576,
-            "audio_s":198.734375,
-            "encode_ms":3534.2539999999999,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kultna Shavla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when spaceflight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, \"Lift your eyes and look to the heavens, who created all these. He who brings out the starry hosts one by one and calls them each by name. Because of His great power and mighty strength, not one of them is missing.\" The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families, and may God continue to bless America. Thank you."
-          },
-          "asr:hp0.wav":{
-            "ms":6574.8400000000001,
-            "audio_s":273.28724999999997,
-            "encode_ms":5305.4690000000001,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          },
-          "asr:hp0x2.wav":{
-            "ms":12653.338,
-            "audio_s":546.57449999999994,
-            "encode_ms":10234.632,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, Available at www.gnu.org slash copyleft slash fdl.html Henry F. Phillips From Wikipedia, the free encyclopedia at en.wikipedia.org Henry F. Phillips, 1890-1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the crosshead concept forward, to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex Allen, Robertson, Tri-Wing, Torxet, Spannerhead, Triple Square, XZN. Others, Poly Drive, Spline Drive, Double Hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-large-v3-turbo.bin",
-            "sha256":"1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69",
-            "bytes":1624555275
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"metal",
@@ -27178,107 +26429,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m ggml-large-v3-turbo.bin -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":139.648,
-            "audio_s":11,
-            "encode_ms":100.104,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":311.93599999999998,
-            "audio_s":33,
-            "encode_ms":199.636,
-            "text":" And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":1468.098,
-            "audio_s":198.734375,
-            "encode_ms":797.19299999999998,
-            "text":" My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kultna Shavla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when spaceflight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, \"Lift your eyes and look to the heavens, who created all these. He who brings out the starry hosts one by one and calls them each by name. Because of His great power and mighty strength, not one of them is missing.\" The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families, and may God continue to bless America. Thank you."
-          },
-          "asr:hp0.wav":{
-            "ms":1999.721,
-            "audio_s":273.28724999999997,
-            "encode_ms":1208.355,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          },
-          "asr:hp0x2.wav":{
-            "ms":3860.2979999999998,
-            "audio_s":546.57449999999994,
-            "encode_ms":2304.7379999999998,
-            "text":" Henry F. Phillips, from Wikipedia, the Free Encyclopedia, at en.wikipedia.org. Henry F. Phillips, from Wikipedia, the Free Encyclopedia. henry f phillips 1890 to 1958 a u s businessman from portland oregon has the honor of having the phillips head screw and screwdriver named after him the importance of the cross-head screw design lies in its self-centering property useful on automated production lines that use powered screw-drivers philip's major contribution was in driving the cross-head concept forward to the point where it was adopted by screw makers and automobile companies Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex, Allen. Robertson. Tri-wing. Torxet. Spannerhead. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, Available at www.gnu.org slash copyleft slash fdl.html Henry F. Phillips From Wikipedia, the free encyclopedia at en.wikipedia.org Henry F. Phillips, 1890-1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the crosshead screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the crosshead concept forward, to the point where it was adopted by screwmakers and automobile companies. Although he received patents for the design in 1936, U.S. Patent No. 2,046,343, U.S. Patents 2,046,837 to 2,046,840, It was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the PosaDrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article. Caption, Phillips Screw Head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly, erroneously, flathead. Phillips, crosshead. Posa drive, super drive. Torx. Hex Allen, Robertson, Tri-Wing, Torxet, Spannerhead, Triple Square, XZN. Others, Poly Drive, Spline Drive, Double Hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a U.S. registered 501c3 tax-deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org slash copyleft slash fdl.html"
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"5bb0cdbbe45233cc8ea5a048c6a9239940308c1dcce98291e1dd702421f3d3f8",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"ggml-large-v3-turbo.bin",
-            "sha256":"1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69",
-            "bytes":1624555275
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"whisper-cli",
         "backend":"cpu",
@@ -28150,113 +27300,6 @@
         "comment":"On jfk.wav the reference's decode phase runs away (41.7 s of generation vs 30 ms on jfk3.wav; reproduced 3x with --temp 0 --reasoning off) - the two engines emit different amounts of text there, so that clip's ratio is a behavior difference, not a speed measurement.",
         "void_clips":"jfk.wav"
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m Qwen3-Omni-30B-A3B-Instruct-Q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":400.69200000000001,
-            "audio_s":11,
-            "encode_ms":37.390000000000001,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":482.27499999999998,
-            "audio_s":33,
-            "encode_ms":98.787000000000006,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":6080.7200000000003,
-            "audio_s":198.734375,
-            "encode_ms":546.71600000000001,
-            "text":"My fellow Americans, this day has brought terrible news and great sadness to our country. At nine o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven: Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kalpana Chawla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, \"Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one and calls them each by name. Because of his great power and mighty strength, not one of them is missing.\" The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth. Yet we can pray that all are safely home. May God bless the grieving families, and may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":8007.5699999999997,
-            "audio_s":273.28724999999997,
-            "encode_ms":803.96299999999997,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en dot wikipedia dot org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, eighteen ninety to nineteen fifty eight, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines, that use powered screwdrivers. Phillips major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in nineteen thirty six, U.S. patent number two million forty six thousand, three hundred forty three, U.S. patents two million forty six thousand, eight hundred thirty seven, to two million forty six thousand, eight hundred forty. It was so widely copied, that by nineteen forty nine, Phillips lost his patent. The American Screw Company, was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the nineteen thirties dismissed the Phillips concept, since it calls for a relatively complex, recessed socket shape, in the head of the screw. As distinct from the simple milled slot, of a slotted type screw. The Phillips Screw Company, and the American Screw Company, went on to devise the Pozidriv screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an infobox which accompanies this article. Infobox, part of the series on screw drive types. Slotted, commonly erroneously flathead. Phillips, crosshead. Pozidriv, Supadriv. Torx. Hex, Allen. Robertson. Tri-wing. Torx set. Spanner head. Triple square, XZN. Others, Polydrive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the ninth of April, two thousand eight, at seventeen oh four. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered five hundred one C three, tax deductible nonprofit charity. This sound file and all text in the article, are licensed under the GNU Free Documentation License, available at www dot g n u dot org slash copyleft slash f d l dot h t m l."
-          },
-          "asr:hp0x2.wav":{
-            "ms":21452.121999999999,
-            "audio_s":546.57449999999994,
-            "encode_ms":1623.6020000000001,
-            "text":"Henry F Phillips from Wikipedia, the free encyclopedia at en dot wikipedia dot org. Henry F Phillips from Wikipedia, the free encyclopedia. Henry F Phillips, eighteen ninety to nineteen fifty eight, a U S businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines, that use powered screwdrivers. Phillips major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in nineteen thirty six, U S patent number two million forty six thousand, three hundred forty three, U S patents two million forty six thousand, eight hundred thirty seven, to two million forty six thousand, eight hundred forty. It was so widely copied, that by nineteen forty nine, Phillips lost his patent. The American Screw Company, was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the nineteen thirties dismissed the Phillips concept, since it calls for a relatively complex, recessed socket shape, in the head of the screw. As distinct from the simple milled slot, of a slotted type screw. The Phillips Screw Company, and the American Screw Company, went on to devise the Pozidriv screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an infobox which accompanies this article. Infobox, part of the series on screw drive types. Slotted, commonly erroneously flathead. Phillips, crosshead. Pozidriv, Supadriv. Torx. Hex, Allen. Robertson. Tri wing. Torx set. Spanner head. Triple square, XZN. Others, Poly Drive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the ninth of April, two thousand eight, at seventeen oh four. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U S registered five hundred and one C three, tax deductible nonprofit charity. This sound file and all text in the article, are licensed under the GNU Free Documentation License, available at, w w w dot g n u dot org slash copyleft slash f d l dot h t m l. Henry F Phillips, from Wikipedia, the free encyclopedia, at en dot wikipedia dot org. Henry F Phillips. From Wikipedia, the free encyclopedia. Henry F Phillips, eighteen ninety to nineteen fifty eight, a U S businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines, that use powered screwdrivers. Phillips major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in nineteen thirty six, U S patent number two million forty six thousand, three hundred forty three, U S patents two million forty six thousand, eight hundred thirty seven, to two million forty six thousand, eight hundred forty. It was so widely copied, that by nineteen forty nine, Phillips lost his patent. The American Screw Company, was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the nineteen thirties dismissed the Phillips concept, since it calls for a relatively complex, recessed socket shape, in the head of the screw. As distinct from the simple milled slot, of a slotted type screw. The Phillips Screw Company, and the American Screw Company, went on to devise the Pozidriv screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an infobox which accompanies this article. Infobox, part of the series on screw drive types. Slotted, commonly erroneously flathead. Phillips, crosshead. Pozidriv, Supadriv. Torx. Hex, Allen. Robertson. Tri wing. Torx set. Spanner head. Triple square, XZN. Others, Poly Drive, spline drive, double hex. Many images accompanied this infobox. This page was last modified on the ninth of April, two thousand eight, at seventeen oh four. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U S registered five hundred and one C three, tax deductible nonprofit charity. This sound file and all text in the article, are licensed under the GNU Free Documentation License, available at, w w w dot g n u dot org slash copyleft slash f d l dot h t m l."
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-Omni-30B-A3B-Instruct-Q8_0.gguf",
-            "sha256":"8a50e5a7d29ae6a28fea9ca45e3bb0a142e76ec07e6787a7703cd498eb08ffaa",
-            "bytes":32484494336
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-Omni-30B-A3B-Instruct-bf16.gguf",
-            "sha256":"f0dfe825fb692d426362b1ac79678fc08daa4758f7151526cad110515f122883",
-            "bytes":2207465568
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
       {
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
@@ -29462,13 +28505,13 @@
         ]
       },
       {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
+        "engine":"llama-mtmd-cli",
+        "backend":"cpu",
+        "flavor":"stock",
         "box":"m4",
         "threads":10,
         "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m Qwen3-ASR-0.6B-Q8_0.gguf -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
+        "cmd":"~/llama.cpp-mtmd-ref/build-cpu/bin/llama-mtmd-cli -m ~/models/Qwen3-ASR-0.6B-Q8_0.gguf --mmproj ~/models/mmproj-Qwen3-ASR-0.6B-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 0 -t 10",
         "hardware":{
           "cpu":"Apple M4 Pro",
           "arch":"arm64",
@@ -29482,47 +28525,25 @@
         },
         "tests":{
           "asr:jfk.wav":{
-            "ms":197.761,
-            "audio_s":11,
-            "encode_ms":48.951000000000001,
-            "text":"And so, my fellow Americans, ask not what your country can do for you; ask what you can do for your country."
+            "ms":1826.0999999999999,
+            "encode_ms":1704,
+            "text":"0.00.005.580 I common_init_result: fitting params to device memory ... 0.00.005.582 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.115.100 I common_params_fit_impl: projected to use 7927 MiB of host memory vs. 65536 MiB of total host memory 0.00.181.200 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.671.797 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.00.760.276 I mtmd_cli_context: chat template example: <|im_start|>system You are a helpful assistant<|im_end|> <|im_start|>user Hello<|im_end|> <|im_start|>assistant Hi there<|im_end|> <|im_start|>user How are you?<|im_end|> <|im_start|>assistant 0.00.830.880 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.00.830.933 I main: loading model: ~/models/Qwen3-ASR-0.6B-Q8_0.gguf 0.00.831.105 W WARN: This is an experimental CLI for testing multimodal capability. 0.00.831.107 W       For normal use cases, please use the standard llama-cli 0.00.839.142 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 4) 0.01.929.833 I mtmd batch encoding done in 1090 ms 0.01.978.219 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 4) 0.02.500.699 I mtmd batch encoding done in 522 ms language English<asr_text>And so, my fellow Americans, ask not what your country can do for you; ask what you can do for your country.DASLLAMA_IDS: 11528 6364 151704 3036 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 26 2548 1128 498 646 653 369 697 3146 13 151645"
           },
           "asr:jfk3.wav":{
-            "ms":527.50599999999997,
-            "audio_s":33,
-            "encode_ms":125.20999999999999,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
+            "ms":5134.6000000000004,
+            "encode_ms":4743.6999999999998,
+            "text":"0.00.001.903 I common_init_result: fitting params to device memory ... 0.00.001.907 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.109.098 I common_params_fit_impl: projected to use 7927 MiB of host memory vs. 65536 MiB of total host memory 0.00.177.888 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.665.423 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.00.747.622 I mtmd_cli_context: chat template example: <|im_start|>system You are a helpful assistant<|im_end|> <|im_start|>user Hello<|im_end|> <|im_start|>assistant Hi there<|im_end|> <|im_start|>user How are you?<|im_end|> <|im_start|>assistant 0.00.815.975 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.00.816.024 I main: loading model: ~/models/Qwen3-ASR-0.6B-Q8_0.gguf 0.00.816.204 W WARN: This is an experimental CLI for testing multimodal capability. 0.00.816.205 W       For normal use cases, please use the standard llama-cli 0.00.831.898 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 7) 0.01.920.045 I mtmd batch encoding done in 1088 ms 0.01.968.334 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 7) 0.03.005.025 I mtmd batch encoding done in 1036 ms 0.03.058.976 I encoding mtmd batch, n_chunks = 1 (done = 3, total = 7) 0.04.096.497 I mtmd batch encoding done in 1038 ms 0.04.156.493 I encoding mtmd batch, n_chunks = 1 (done = 4, total = 7) 0.05.193.847 I mtmd batch encoding done in 1037 ms 0.05.261.422 I encoding mtmd batch, n_chunks = 1 (done = 5, total = 7) 0.05.529.066 I mtmd batch encoding done in 267 ms language English<asr_text>And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country.DASLLAMA_IDS: 11528 6364 151704 3036 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 11 2548 1128 498 646 653 369 697 3146 13 1597 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 11 2548 1128 498 646 653 369 697 3146 13 1597 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 11 2548 1128 498 646 653 369 697 3146 13 151645"
           },
           "asr:gb1.wav":{
-            "ms":4049.2089999999998,
-            "audio_s":198.734375,
-            "encode_ms":725.69500000000005,
-            "text":"My fellow Americans. This day has brought terrible news. In great sadness to our country. At nine o'clock this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Doctor Kulpina Shavla, and Elon Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket. And the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers. And they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well. Of the families of these men and women, who have been given this sudden shock in grief. You are not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude. Of this country, the cause in which they died will continue. Mankind is led into the darkness. Beyond our world, by the inspiration of discovery. And the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah. Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one. And calls them each by name. Because of his great power. And mighty strength, not one of them is missing. The same creator who names the stars. Also knows the names. Of the seven souls we mourn today. The crew of the shuttle Columbia. Did not return safely to Earth. Yet we can pray. That all are safely home. May God bless the grieving families. And may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":5593.7709999999997,
-            "audio_s":273.28724999999997,
-            "encode_ms":985.17600000000004,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. Patent Number 2,000,46,000,343, U.S. Patents 2,000,46,000,837 to 2,000,46,000,840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape, in the head of the screw. As distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company, went on to devise the Posidrive screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly erroneously flat head. Phillips cross head. Posidrive, Supadrive. Torx. Hex, Allen. Robertson. Triwing. Torxet. Spanner head. Triple square, XZN. Others, Polydrive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April 2008, at 17:04. All text is available under the terms of the GNU Free Documentation License, see copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered 501c3, tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/slash, copyleft/slash, fdl.shtml."
-          },
-          "asr:hp0x2.wav":{
-            "ms":14705.468999999999,
-            "audio_s":546.57449999999994,
-            "encode_ms":1991.6310000000001,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958. A U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. patent number 2,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00"
+            "ms":32921.699999999997,
+            "encode_ms":29501,
+            "text":"0.00.001.910 I common_init_result: fitting params to device memory ... 0.00.001.914 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.106.129 I common_params_fit_impl: projected to use 7927 MiB of host memory vs. 65536 MiB of total host memory 0.00.174.219 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.660.926 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.00.744.178 I mtmd_cli_context: chat template example: <|im_start|>system You are a helpful assistant<|im_end|> <|im_start|>user Hello<|im_end|> <|im_start|>assistant Hi there<|im_end|> <|im_start|>user How are you?<|im_end|> <|im_start|>assistant 0.00.811.542 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.00.811.587 I main: loading model: ~/models/Qwen3-ASR-0.6B-Q8_0.gguf 0.00.811.777 W WARN: This is an experimental CLI for testing multimodal capability. 0.00.811.779 W       For normal use cases, please use the standard llama-cli 0.00.879.371 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 27) 0.01.966.088 I mtmd batch encoding done in 1086 ms 0.02.014.407 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 27) 0.03.051.313 I mtmd batch encoding done in 1036 ms 0.03.105.228 I encoding mtmd batch, n_chunks = 1 (done = 3, total = 27) 0.04.142.774 I mtmd batch encoding done in 1038 ms 0.04.202.869 I encoding mtmd batch, n_chunks = 1 (done = 4, total = 27) 0.05.240.701 I mtmd batch encoding done in 1038 ms 0.05.308.320 I encoding mtmd batch, n_chunks = 1 (done = 5, total = 27) 0.06.347.428 I mtmd batch encoding done in 1040 ms 0.06.422.753 I encoding mtmd batch, n_chunks = 1 (done = 6, total = 27) 0.07.462.489 I mtmd batch encoding done in 1040 ms 0.07.544.105 I encoding mtmd batch, n_chunks = 1 (done = 7, total = 27) 0.08.585.096 I mtmd batch encoding done in 1041 ms 0.08.674.600 I encoding mtmd batch, n_chunks = 1 (done = 8, total = 27) 0.09.715.148 I mtmd batch encoding done in 1040 ms 0.09.811.999 I encoding mtmd batch, n_chunks = 1 (done = 9, total = 27) 0.10.852.412 I mtmd batch encoding done in 1041 ms 0.10.956.019 I encoding mtmd batch, n_chunks = 1 (done = 10, total = 27) 0.11.997.396 I mtmd batch encoding done in 1042 ms 0.12.110.153 I encoding mtmd batch, n_chunks = 1 (done = 11, total = 27) 0.13.151.404 I mtmd batch encoding done in 1042 ms 0.13.270.811 I encoding mtmd batch, n_chunks = 1 (done = 12, total = 27) 0.14.312.766 I mtmd batch encoding done in 1042 ms 0.14.439.813 I encoding mtmd batch, n_chunks = 1 (done = 13, total = 27) 0.15.482.157 I mtmd batch encoding done in 1042 ms 0.15.617.792 I encoding mtmd batch, n_chunks = 1 (done = 14, total = 27) 0.16.660.486 I mtmd batch encoding done in 1043 ms 0.16.803.238 I encoding mtmd batch, n_chunks = 1 (done = 15, total = 27) 0.17.846.045 I mtmd batch encoding done in 1043 ms 0.17.997.814 I encoding mtmd batch, n_chunks = 1 (done = 16, total = 27) 0.19.040.653 I mtmd batch encoding done in 1043 ms 0.19.200.077 I encoding mtmd batch, n_chunks = 1 (done = 17, total = 27) 0.20.243.534 I mtmd batch encoding done in 1044 ms 0.20.410.857 I encoding mtmd batch, n_chunks = 1 (done = 18, total = 27) 0.21.454.879 I mtmd batch encoding done in 1044 ms 0.21.631.106 I encoding mtmd batch, n_chunks = 1 (done = 19, total = 27) 0.22.675.489 I mtmd batch encoding done in 1045 ms 0.22.859.729 I encoding mtmd batch, n_chunks = 1 (done = 20, total = 27) 0.23.904.321 I mtmd batch encoding done in 1044 ms 0.24.097.701 I encoding mtmd batch, n_chunks = 1 (done = 21, total = 27) 0.25.143.184 I mtmd batch encoding done in 1045 ms 0.25.345.508 I encoding mtmd batch, n_chunks = 1 (done = 22, total = 27) 0.26.390.660 I mtmd batch encoding done in 1045 ms 0.26.600.718 I encoding mtmd batch, n_chunks = 1 (done = 23, total = 27) 0.27.647.281 I mtmd batch encoding done in 1046 ms 0.27.866.235 I encoding mtmd batch, n_chunks = 1 (done = 24, total = 27) 0.28.912.631 I mtmd batch encoding done in 1047 ms 0.29.140.757 I encoding mtmd batch, n_chunks = 1 (done = 25, total = 27) 0.30.052.164 I mtmd batch encoding done in 911 ms language English<asr_text>My fellow Americans. This day has brought terrible news. In great sadness to our country. At nine o'clock this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Doctor Kulpina Shavla, and Elon Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket. And the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers. And they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well. Of the families of these men and women, who have been given this sudden shock in grief. You are not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude. Of this country, the cause in which they died will continue. Mankind is led into the darkness. Beyond our world, by the inspiration of discovery. And the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see. There is comfort and hope. In the words of the prophet Isaiah. Lift your eyes, and look to the heavens. Who created all these? He who brings out the starry hosts one by one. And calls them each by name. Because of his great power. And mighty strength, not one of them is missing. The same creator who names the stars. Also knows the names. Of the seven souls we mourn today. The crew of the shuttle Columbia. Did not return safely to Earth. Yet we can pray. That all are safely home. May God bless the grieving families. And may God continue to bless America.DASLLAMA_IDS: 11528 6364 151704 5050 12357 8877 13 1096 1899 702 7117 17478 3669 13 758 2244 50878 311 1039 3146 13 2411 11627 297 62410 419 6556 11 8954 2524 304 16003 5558 3645 448 1039 3550 44541 18796 13 362 2805 882 2937 11 33998 572 3884 15679 504 279 49293 3403 8257 13 576 18796 374 5558 13 2619 525 902 31596 13 1913 4479 572 264 13627 315 8094 13 51698 22388 73359 11 54137 51698 7937 20642 11 34138 80464 21304 11 21316 6798 10471 11 34138 12375 14249 1749 11 18635 730 12840 2210 1417 402 4260 11 323 68539 15152 263 11 264 14889 301 304 279 15907 6553 11732 13 4220 2953 323 3198 19110 2244 5214 304 279 2473 311 678 21941 13 758 458 4231 979 3550 10971 702 2525 311 2803 4558 14021 11 432 374 4135 311 30705 279 35964 315 5821 553 24306 13 1597 279 26038 315 59399 279 41342 15955 16566 315 279 9237 13 4220 68422 6876 279 35964 13 1597 807 16601 1105 72552 11 14063 807 1030 264 1550 323 34382 7428 304 2272 13 9211 315 862 24744 323 58672 323 10507 2142 11 582 686 3116 1105 678 279 803 13 2009 8877 3351 525 7274 438 1632 13 4940 279 8521 315 1493 2953 323 3198 11 879 614 1012 2661 419 10968 10755 304 37284 13 1446 525 537 7484 13 5633 4453 6995 342 7231 2342 448 498 13 1597 1846 498 10245 686 2677 614 279 5091 323 45035 13 4940 419 3146 11 279 5240 304 892 807 8469 686 3060 13 386 69270 374 6069 1119 279 26298 13 30786 1039 1879 11 553 279 19760 315 18335 13 1597 279 78322 311 3535 13 5633 11618 1119 3550 686 728 389 13 758 279 49293 3351 11 582 5485 19258 323 30826 13 14626 42626 1091 582 646 1490 13 2619 374 6838 323 3900 13 758 279 4244 315 279 52504 63430 13 52435 697 6414 11 323 1401 311 279 62780 13 10479 3465 678 1493 30 1260 879 12434 700 279 6774 884 18432 825 553 825 13 1597 6738 1105 1817 553 829 13 9211 315 806 2244 2355 13 1597 41627 8170 11 537 825 315 1105 374 7402 13 576 1852 19919 879 5036 279 9759 13 7281 8788 279 5036 13 4940 279 8094 34726 582 59134 3351 13 576 13627 315 279 44541 18796 13 14568 537 470 21000 311 9237 13 14626 582 646 23803 13 2938 678 525 21000 2114 13 3217 4264 16072 279 90744 8521 13 1597 1231 4264 3060 311 16072 5159 13 151645"
           }
         },
         "workload":"audio-chat",
         "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
+        "versions":"llama.cpp @ ebd048fc5 + mtmd-timing.patch@8026b1bd",
+        "exec_fmt":"bf16/q8_0",
         "files":[
           {
             "role":"weights",
@@ -29553,18 +28574,6 @@
             "name":"gb1.wav",
             "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
             "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
           }
         ]
       },
@@ -29572,192 +28581,12 @@
         "engine":"llama-mtmd-cli",
         "backend":"cpu",
         "flavor":"stock",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"~/llama.cpp-mtmd-ref/build-cpu/bin/llama-mtmd-cli -m ~/models/Qwen3-ASR-0.6B-Q8_0.gguf --mmproj ~/models/mmproj-Qwen3-ASR-0.6B-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 0 -t 10",
+        "box":"m5",
+        "threads":6,
+        "date":"2026-09-22",
+        "cmd":"../llama.cpp-mtmd-ref/build-cpu/bin/llama-mtmd-cli -m ~/Work/llama.cpp/models/Qwen3-ASR-0.6B-Q8_0.gguf --mmproj ~/Work/llama.cpp/models/mmproj-Qwen3-ASR-0.6B-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 0 -t 6",
         "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":1826.0999999999999,
-            "encode_ms":1704,
-            "text":"0.00.005.580 I common_init_result: fitting params to device memory ... 0.00.005.582 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.115.100 I common_params_fit_impl: projected to use 7927 MiB of host memory vs. 65536 MiB of total host memory 0.00.181.200 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.671.797 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.00.760.276 I mtmd_cli_context: chat template example: <|im_start|>system You are a helpful assistant<|im_end|> <|im_start|>user Hello<|im_end|> <|im_start|>assistant Hi there<|im_end|> <|im_start|>user How are you?<|im_end|> <|im_start|>assistant 0.00.830.880 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.00.830.933 I main: loading model: ~/models/Qwen3-ASR-0.6B-Q8_0.gguf 0.00.831.105 W WARN: This is an experimental CLI for testing multimodal capability. 0.00.831.107 W       For normal use cases, please use the standard llama-cli 0.00.839.142 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 4) 0.01.929.833 I mtmd batch encoding done in 1090 ms 0.01.978.219 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 4) 0.02.500.699 I mtmd batch encoding done in 522 ms language English<asr_text>And so, my fellow Americans, ask not what your country can do for you; ask what you can do for your country.DASLLAMA_IDS: 11528 6364 151704 3036 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 26 2548 1128 498 646 653 369 697 3146 13 151645"
-          },
-          "asr:jfk3.wav":{
-            "ms":5134.6000000000004,
-            "encode_ms":4743.6999999999998,
-            "text":"0.00.001.903 I common_init_result: fitting params to device memory ... 0.00.001.907 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.109.098 I common_params_fit_impl: projected to use 7927 MiB of host memory vs. 65536 MiB of total host memory 0.00.177.888 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.665.423 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.00.747.622 I mtmd_cli_context: chat template example: <|im_start|>system You are a helpful assistant<|im_end|> <|im_start|>user Hello<|im_end|> <|im_start|>assistant Hi there<|im_end|> <|im_start|>user How are you?<|im_end|> <|im_start|>assistant 0.00.815.975 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.00.816.024 I main: loading model: ~/models/Qwen3-ASR-0.6B-Q8_0.gguf 0.00.816.204 W WARN: This is an experimental CLI for testing multimodal capability. 0.00.816.205 W       For normal use cases, please use the standard llama-cli 0.00.831.898 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 7) 0.01.920.045 I mtmd batch encoding done in 1088 ms 0.01.968.334 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 7) 0.03.005.025 I mtmd batch encoding done in 1036 ms 0.03.058.976 I encoding mtmd batch, n_chunks = 1 (done = 3, total = 7) 0.04.096.497 I mtmd batch encoding done in 1038 ms 0.04.156.493 I encoding mtmd batch, n_chunks = 1 (done = 4, total = 7) 0.05.193.847 I mtmd batch encoding done in 1037 ms 0.05.261.422 I encoding mtmd batch, n_chunks = 1 (done = 5, total = 7) 0.05.529.066 I mtmd batch encoding done in 267 ms language English<asr_text>And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country.DASLLAMA_IDS: 11528 6364 151704 3036 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 11 2548 1128 498 646 653 369 697 3146 13 1597 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 11 2548 1128 498 646 653 369 697 3146 13 1597 773 11 847 12357 8877 11 2548 537 1128 697 3146 646 653 369 498 11 2548 1128 498 646 653 369 697 3146 13 151645"
-          },
-          "asr:gb1.wav":{
-            "ms":32921.699999999997,
-            "encode_ms":29501,
-            "text":"0.00.001.910 I common_init_result: fitting params to device memory ... 0.00.001.914 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on) 0.00.106.129 I common_params_fit_impl: projected to use 7927 MiB of host memory vs. 65536 MiB of total host memory 0.00.174.219 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden 0.00.660.926 I common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable) 0.00.744.178 I mtmd_cli_context: chat template example: <|im_start|>system You are a helpful assistant<|im_end|> <|im_start|>user Hello<|im_end|> <|im_start|>assistant Hi there<|im_end|> <|im_start|>user How are you?<|im_end|> <|im_start|>assistant 0.00.811.542 W init_audio: audio input is in experimental stage and may have reduced quality: https://github.com/ggml-org/llama.cpp/discussions/13759 0.00.811.587 I main: loading model: ~/models/Qwen3-ASR-0.6B-Q8_0.gguf 0.00.811.777 W WARN: This is an experimental CLI for testing multimodal capability. 0.00.811.779 W       For normal use cases, please use the standard llama-cli 0.00.879.371 I encoding mtmd batch, n_chunks = 1 (done = 1, total = 27) 0.01.966.088 I mtmd batch encoding done in 1086 ms 0.02.014.407 I encoding mtmd batch, n_chunks = 1 (done = 2, total = 27) 0.03.051.313 I mtmd batch encoding done in 1036 ms 0.03.105.228 I encoding mtmd batch, n_chunks = 1 (done = 3, total = 27) 0.04.142.774 I mtmd batch encoding done in 1038 ms 0.04.202.869 I encoding mtmd batch, n_chunks = 1 (done = 4, total = 27) 0.05.240.701 I mtmd batch encoding done in 1038 ms 0.05.308.320 I encoding mtmd batch, n_chunks = 1 (done = 5, total = 27) 0.06.347.428 I mtmd batch encoding done in 1040 ms 0.06.422.753 I encoding mtmd batch, n_chunks = 1 (done = 6, total = 27) 0.07.462.489 I mtmd batch encoding done in 1040 ms 0.07.544.105 I encoding mtmd batch, n_chunks = 1 (done = 7, total = 27) 0.08.585.096 I mtmd batch encoding done in 1041 ms 0.08.674.600 I encoding mtmd batch, n_chunks = 1 (done = 8, total = 27) 0.09.715.148 I mtmd batch encoding done in 1040 ms 0.09.811.999 I encoding mtmd batch, n_chunks = 1 (done = 9, total = 27) 0.10.852.412 I mtmd batch encoding done in 1041 ms 0.10.956.019 I encoding mtmd batch, n_chunks = 1 (done = 10, total = 27) 0.11.997.396 I mtmd batch encoding done in 1042 ms 0.12.110.153 I encoding mtmd batch, n_chunks = 1 (done = 11, total = 27) 0.13.151.404 I mtmd batch encoding done in 1042 ms 0.13.270.811 I encoding mtmd batch, n_chunks = 1 (done = 12, total = 27) 0.14.312.766 I mtmd batch encoding done in 1042 ms 0.14.439.813 I encoding mtmd batch, n_chunks = 1 (done = 13, total = 27) 0.15.482.157 I mtmd batch encoding done in 1042 ms 0.15.617.792 I encoding mtmd batch, n_chunks = 1 (done = 14, total = 27) 0.16.660.486 I mtmd batch encoding done in 1043 ms 0.16.803.238 I encoding mtmd batch, n_chunks = 1 (done = 15, total = 27) 0.17.846.045 I mtmd batch encoding done in 1043 ms 0.17.997.814 I encoding mtmd batch, n_chunks = 1 (done = 16, total = 27) 0.19.040.653 I mtmd batch encoding done in 1043 ms 0.19.200.077 I encoding mtmd batch, n_chunks = 1 (done = 17, total = 27) 0.20.243.534 I mtmd batch encoding done in 1044 ms 0.20.410.857 I encoding mtmd batch, n_chunks = 1 (done = 18, total = 27) 0.21.454.879 I mtmd batch encoding done in 1044 ms 0.21.631.106 I encoding mtmd batch, n_chunks = 1 (done = 19, total = 27) 0.22.675.489 I mtmd batch encoding done in 1045 ms 0.22.859.729 I encoding mtmd batch, n_chunks = 1 (done = 20, total = 27) 0.23.904.321 I mtmd batch encoding done in 1044 ms 0.24.097.701 I encoding mtmd batch, n_chunks = 1 (done = 21, total = 27) 0.25.143.184 I mtmd batch encoding done in 1045 ms 0.25.345.508 I encoding mtmd batch, n_chunks = 1 (done = 22, total = 27) 0.26.390.660 I mtmd batch encoding done in 1045 ms 0.26.600.718 I encoding mtmd batch, n_chunks = 1 (done = 23, total = 27) 0.27.647.281 I mtmd batch encoding done in 1046 ms 0.27.866.235 I encoding mtmd batch, n_chunks = 1 (done = 24, total = 27) 0.28.912.631 I mtmd batch encoding done in 1047 ms 0.29.140.757 I encoding mtmd batch, n_chunks = 1 (done = 25, total = 27) 0.30.052.164 I mtmd batch encoding done in 911 ms language English<asr_text>My fellow Americans. This day has brought terrible news. In great sadness to our country. At nine o'clock this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Doctor Kulpina Shavla, and Elon Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket. And the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers. And they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well. Of the families of these men and women, who have been given this sudden shock in grief. You are not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude. Of this country, the cause in which they died will continue. Mankind is led into the darkness. Beyond our world, by the inspiration of discovery. And the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see. There is comfort and hope. In the words of the prophet Isaiah. Lift your eyes, and look to the heavens. Who created all these? He who brings out the starry hosts one by one. And calls them each by name. Because of his great power. And mighty strength, not one of them is missing. The same creator who names the stars. Also knows the names. Of the seven souls we mourn today. The crew of the shuttle Columbia. Did not return safely to Earth. Yet we can pray. That all are safely home. May God bless the grieving families. And may God continue to bless America.DASLLAMA_IDS: 11528 6364 151704 5050 12357 8877 13 1096 1899 702 7117 17478 3669 13 758 2244 50878 311 1039 3146 13 2411 11627 297 62410 419 6556 11 8954 2524 304 16003 5558 3645 448 1039 3550 44541 18796 13 362 2805 882 2937 11 33998 572 3884 15679 504 279 49293 3403 8257 13 576 18796 374 5558 13 2619 525 902 31596 13 1913 4479 572 264 13627 315 8094 13 51698 22388 73359 11 54137 51698 7937 20642 11 34138 80464 21304 11 21316 6798 10471 11 34138 12375 14249 1749 11 18635 730 12840 2210 1417 402 4260 11 323 68539 15152 263 11 264 14889 301 304 279 15907 6553 11732 13 4220 2953 323 3198 19110 2244 5214 304 279 2473 311 678 21941 13 758 458 4231 979 3550 10971 702 2525 311 2803 4558 14021 11 432 374 4135 311 30705 279 35964 315 5821 553 24306 13 1597 279 26038 315 59399 279 41342 15955 16566 315 279 9237 13 4220 68422 6876 279 35964 13 1597 807 16601 1105 72552 11 14063 807 1030 264 1550 323 34382 7428 304 2272 13 9211 315 862 24744 323 58672 323 10507 2142 11 582 686 3116 1105 678 279 803 13 2009 8877 3351 525 7274 438 1632 13 4940 279 8521 315 1493 2953 323 3198 11 879 614 1012 2661 419 10968 10755 304 37284 13 1446 525 537 7484 13 5633 4453 6995 342 7231 2342 448 498 13 1597 1846 498 10245 686 2677 614 279 5091 323 45035 13 4940 419 3146 11 279 5240 304 892 807 8469 686 3060 13 386 69270 374 6069 1119 279 26298 13 30786 1039 1879 11 553 279 19760 315 18335 13 1597 279 78322 311 3535 13 5633 11618 1119 3550 686 728 389 13 758 279 49293 3351 11 582 5485 19258 323 30826 13 14626 42626 1091 582 646 1490 13 2619 374 6838 323 3900 13 758 279 4244 315 279 52504 63430 13 52435 697 6414 11 323 1401 311 279 62780 13 10479 3465 678 1493 30 1260 879 12434 700 279 6774 884 18432 825 553 825 13 1597 6738 1105 1817 553 829 13 9211 315 806 2244 2355 13 1597 41627 8170 11 537 825 315 1105 374 7402 13 576 1852 19919 879 5036 279 9759 13 7281 8788 279 5036 13 4940 279 8094 34726 582 59134 3351 13 576 13627 315 279 44541 18796 13 14568 537 470 21000 311 9237 13 14626 582 646 23803 13 2938 678 525 21000 2114 13 3217 4264 16072 279 90744 8521 13 1597 1231 4264 3060 311 16072 5159 13 151645"
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "versions":"llama.cpp @ ebd048fc5 + mtmd-timing.patch@8026b1bd",
-        "exec_fmt":"bf16/q8_0",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-ASR-0.6B-Q8_0.gguf",
-            "sha256":"bca259818b50ca7c4c05e9bdb35a5dc04fa039653a6d6f3f0f331f96f6aa1971",
-            "bytes":804749248
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-ASR-0.6B-bf16.gguf",
-            "sha256":"dae36c855f9a82a8916bea2238b24bda69a39d8da8b2f46dee7c103775656039",
-            "bytes":378575520
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          }
-        ]
-      },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m Qwen3-ASR-0.6B-Q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":105.40000000000001,
-            "audio_s":11,
-            "encode_ms":21.899999999999999,
-            "text":"And so, my fellow Americans, ask not what your country can do for you; ask what you can do for your country."
-          },
-          "asr:jfk3.wav":{
-            "ms":286.846,
-            "audio_s":33,
-            "encode_ms":60.396999999999998,
-            "text":"And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country. And so, my fellow Americans, ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":1979.1700000000001,
-            "audio_s":198.734375,
-            "encode_ms":332.49000000000001,
-            "text":"My fellow Americans. This day has brought terrible news. In great sadness to our country. At nine o'clock this morning, mission control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Doctor Kulpina Shavla, and Elon Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when space flight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket. And the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers. And they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well. Of the families of these men and women, who have been given this sudden shock in grief. You are not alone. Our entire nation grieves with you. And those you loved will always have the respect and gratitude. Of this country, the cause in which they died will continue. Mankind is led into the darkness. Beyond our world, by the inspiration of discovery. And the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah. Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one. And calls them each by name. Because of his great power. And mighty strength, not one of them is missing. The same creator who names the stars. Also knows the names. Of the seven souls we mourn today. The crew of the shuttle Columbia. Did not return safely to Earth. Yet we can pray. That all are safely home. May God bless the grieving families. And may God continue to bless America."
-          },
-          "asr:hp0.wav":{
-            "ms":2723.636,
-            "audio_s":273.28724999999997,
-            "encode_ms":451.142,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. Patent Number 2,000,46,000,343, U.S. Patents 2,000,46,000,837 to 2,000,46,000,840. It was so widely copied that by 1949, Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape, in the head of the screw. As distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company, went on to devise the Posidrive screw, which differs from the Phillips, in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, caption, Phillips screw head. The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly erroneously flat head. Phillips cross head. Posidrive, Supadrive. Torx. Hex, Allen. Robertson. Triwing. Torxet. Spanner head. Triple square, XZN. Others, Polydrive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April 2008, at 17:04. All text is available under the terms of the GNU Free Documentation License, see copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered 501c3, tax deductible non-profit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/slash, copyleft/slash, fdl.shtml."
-          },
-          "asr:hp0x2.wav":{
-            "ms":7310.8400000000001,
-            "audio_s":546.57449999999994,
-            "encode_ms":931.44100000000003,
-            "text":"Henry F. Phillips, from Wikipedia, the free encyclopedia, at en.wikipedia.org. Henry F. Phillips. From Wikipedia, the free encyclopedia. Henry F. Phillips, 1890 to 1958. A U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design, lies in its self centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward, to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. patent number 2,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00"
-          }
-        },
-        "workload":"audio-chat",
-        "source":"official",
-        "sha":"9c5f93d3e",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"6d5bf9ab95592fac7fea5787a29645835383e29f1aab7e70864f1f16549cdfe7",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"Qwen3-ASR-0.6B-Q8_0.gguf",
-            "sha256":"bca259818b50ca7c4c05e9bdb35a5dc04fa039653a6d6f3f0f331f96f6aa1971",
-            "bytes":804749248
-          },
-          {
-            "role":"mmproj",
-            "name":"mmproj-Qwen3-ASR-0.6B-bf16.gguf",
-            "sha256":"dae36c855f9a82a8916bea2238b24bda69a39d8da8b2f46dee7c103775656039",
-            "bytes":378575520
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          },
-          {
-            "role":"clip",
-            "name":"hp0.wav",
-            "sha256":"3a7fbe30706a0c6e7184cda0013dc7ddf731f2ea42ba3dd4ff0f64e6e0d93969",
-            "bytes":8745270
-          },
-          {
-            "role":"clip",
-            "name":"hp0x2.wav",
-            "sha256":"43acaa61356b9a51694ebadeb68c4a2512484da1c69da2fba223cc0bb7cba57c",
-            "bytes":17490462
-          }
-        ]
-      },
-      {
-        "engine":"llama-mtmd-cli",
-        "backend":"cpu",
-        "flavor":"stock",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-22",
-        "cmd":"../llama.cpp-mtmd-ref/build-cpu/bin/llama-mtmd-cli -m ~/Work/llama.cpp/models/Qwen3-ASR-0.6B-Q8_0.gguf --mmproj ~/Work/llama.cpp/models/mmproj-Qwen3-ASR-0.6B-bf16.gguf --audio modules/dasLLAMA/benchmarks/asr/corpus/gb1.wav -p \"Transcribe the audio.\" --temp 0 --jinja --reasoning off -ngl 0 -t 6",
-        "hardware":{
-          "cpu":"Apple M5 Max",
+          "cpu":"Apple M5 Max",
           "arch":"arm64",
           "os":"macOS 26.6.2",
           "perf_cores":6,
@@ -30349,89 +29178,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m4",
-        "threads":10,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m canary-qwen-2.5b-decoder-q8_0.gguf -r 2 -t 10 --json-path modules/dasLLAMA/performance/records/_cell_m4.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M4 Pro",
-          "arch":"arm64",
-          "os":"macOS 26.5.2",
-          "perf_cores":10,
-          "total_cores":14,
-          "ram_gb":64,
-          "gpu":"Apple M4 Pro (20-core)",
-          "model_id":"Mac16,11",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":502.17599999999999,
-            "audio_s":11,
-            "encode_ms":247.83600000000001,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:jfk3.wav":{
-            "ms":1532.3140000000001,
-            "audio_s":33,
-            "encode_ms":742.65300000000002,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":11932.397999999999,
-            "audio_s":198.734375,
-            "encode_ms":10158.396000000001,
-            "text":"My fellow Americans, this day has brought terrible news and great sadness to our country. At nine o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. In the words of the prophet Isaiah, May God bless the grieving families and may God continue to bless America."
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"d6b384d21",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"2b2e79baf8ab94bba26d7b1fbfc6576c8b4780293fbef86debe96b26c5d6bdd9",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m4 DASLLAMA_MODELS_DIR=~/models",
-        "files":[
-          {
-            "role":"weights",
-            "name":"canary-qwen-2.5b-decoder-q8_0.gguf",
-            "sha256":"24c5f521ef7fce86f3752a9566605527921e3c534d27dd9ab262879b4690cabe",
-            "bytes":1834425984
-          },
-          {
-            "role":"mmproj",
-            "name":"canary-qwen-2.5b-encoder-f32.bin",
-            "sha256":"37d1057ced3150cfde2fb996c1fc0a3d702d23a97f9347aedb52795ebec03e5c",
-            "bytes":3252768256
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          }
-        ]
-      },
       {
         "engine":"nemo",
         "backend":"cpu",
@@ -30548,89 +29294,6 @@
           }
         ]
       },
-      {
-        "engine":"das",
-        "backend":"metal",
-        "flavor":"tuned",
-        "box":"m5",
-        "threads":6,
-        "date":"2026-09-23",
-        "cmd":"modules/dasLLAMA/performance/_rig/dasllama-bench.app/Contents/MacOS/dasllama-bench -- --asr -m canary-qwen-2.5b-decoder-q8_0.gguf -r 2 -t 6 --json-path modules/dasLLAMA/performance/records/_cell_m5.json --ngl 1",
-        "hardware":{
-          "cpu":"Apple M5 Max",
-          "arch":"arm64",
-          "os":"macOS 26.6.2",
-          "perf_cores":6,
-          "total_cores":18,
-          "ram_gb":128,
-          "gpu":"Apple M5 Max (40-core)",
-          "model_id":"Mac17,6",
-          "remote_desktop":"off"
-        },
-        "tests":{
-          "asr:jfk.wav":{
-            "ms":321.988,
-            "audio_s":11,
-            "encode_ms":209.85599999999999,
-            "text":"And so my fellow Americans ask not what your country can do for you ask what you can do for your country"
-          },
-          "asr:jfk3.wav":{
-            "ms":892.68399999999997,
-            "audio_s":33,
-            "encode_ms":552.85299999999995,
-            "text":"And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country. And so my fellow Americans ask not what your country can do for you, ask what you can do for your country."
-          },
-          "asr:gb1.wav":{
-            "ms":6502.0730000000003,
-            "audio_s":198.734375,
-            "encode_ms":5862.0429999999997,
-            "text":"My fellow Americans, this day has brought terrible news and great sadness to our country. At nine o'clock this morning, Mission Control in Houston lost contact with our space shuttle Columbia. A short time later, debris was seen falling from the skies above Texas. The Columbia is lost. There are no survivors. In the words of the prophet Isaiah, May God bless the grieving families and may God continue to bless America."
-          }
-        },
-        "workload":"asr",
-        "source":"official",
-        "sha":"ea5747c91",
-        "version":"0.6.4",
-        "dasllama_version":16,
-        "versions":"exe one unit",
-        "tune":"k4q8_tile_gen=mr8 (manifest); k5q8_tile_gen=mr8 (manifest); k6q8_tile_gen=mr8 (manifest); q40q8_tile_gen=mr8 (manifest); iq4xsq8_tile_gen=mr8 (manifest); k3q8_tile_gen=mr8 (manifest); iq3sq8_tile_gen=mr8 (manifest); iq3xxsq8_tile_gen=mr8 (manifest); iq4nlq8_tile_gen=mr8 (manifest); k2q8_tile_gen=mr8 (manifest); iq2sq8_tile_gen=mr8 (manifest); iq2xsq8_tile_gen=mr8 (manifest); iq2xxsq8_tile_gen=mr8 (manifest); q8q8_tile_gen=mr8_budget (manifest); q51q8_tile_gen=mr8 (manifest)",
-        "tune_sha":"5bb0cdbbe45233cc8ea5a048c6a9239940308c1dcce98291e1dd702421f3d3f8",
-        "noise":"ok",
-        "exec_fmt":"f32/q8",
-        "env":"DASLLAMA_BOX=m5",
-        "files":[
-          {
-            "role":"weights",
-            "name":"canary-qwen-2.5b-decoder-q8_0.gguf",
-            "sha256":"24c5f521ef7fce86f3752a9566605527921e3c534d27dd9ab262879b4690cabe",
-            "bytes":1834425984
-          },
-          {
-            "role":"mmproj",
-            "name":"canary-qwen-2.5b-encoder-f32.bin",
-            "sha256":"37d1057ced3150cfde2fb996c1fc0a3d702d23a97f9347aedb52795ebec03e5c",
-            "bytes":3252768256
-          },
-          {
-            "role":"clip",
-            "name":"jfk.wav",
-            "sha256":"59dfb9a4acb36fe2a2affc14bacbee2920ff435cb13cc314a08c13f66ba7860e",
-            "bytes":352078
-          },
-          {
-            "role":"clip",
-            "name":"jfk3.wav",
-            "sha256":"a4d13f9d48ccce40db0621969fdaa39b8bf280e25b9de5eda902decdfe26f484",
-            "bytes":1056078
-          },
-          {
-            "role":"clip",
-            "name":"gb1.wav",
-            "sha256":"b55890c635c795309706aaa40a5c670042d989af43da3512d7e486c989bf0787",
-            "bytes":6359578
-          }
-        ]
-      },
       {
         "engine":"nemo",
         "backend":"cpu",
diff --git a/skills/daslang/references/everything.md b/skills/daslang/references/everything.md
index 5312aca6de..9b146a30ae 100644
--- a/skills/daslang/references/everything.md
+++ b/skills/daslang/references/everything.md
@@ -1341,9 +1341,12 @@ A pure-daslang client for OpenAI-compatible REST APIs — OpenAI itself, plus an
 
 ### Vision
 
+- `audio_request_body` - Builds the JSON body for a one-shot audio request: a user turn with text + one `input_audio` part carrying the base64 of an audio file, the clip ahead of the text under `audio_first`.
+- `chat_audio` - One-shot audio request: a single user turn with text plus an audio clip (the base64 of its file).
 - `chat_vision` - One-shot vision request: a single user turn with text plus an image (http(s) URL or a `data:` URL).
+- `file_base64` - The bytes of the file at `path` as base64 - a byte read, since an image or a clip carries interior NULs a string read stops at; "" for a file that cannot be read.
 - `image_file_data_uri` - The image file at `path` as the `data:` URL a browser would send (`image/png` for a `.png` name, `image/jpeg` otherwise); "" for a file that cannot be read.
-- `vision_request_body` - Builds the JSON body for a one-shot vision request (a user turn with text + one image), under a system message when `system` is not empty.
+- `vision_request_body` - Builds the JSON body for a one-shot vision request (a user turn with text + one image, the image ahead of the text under `image_first`), under a system message when `system` is not empty; `no_think` asks a thinking model to answer directly.
 
 ## stbimage
 
@@ -3185,6 +3188,7 @@ CPU large-language-model inference in pure daslang: load a GGUF model, tokenize,
 - `prefix_checkpoint_at` - Where a recurrent `session`'s prefill of `prompt` should stop for a `prefix_insert`, after `prefix_attach` matched `matched` tokens: `stable_at` (`render_turn_marked`'s opening) when the caller knows it, else the longest opening an earlier checkpoint shares.
 - `prefix_held_groups` - Pages the cache currently holds (== pool groups retained for reuse).
 - `prefix_insert` - Donate a session's KV pages to the cache.
+- `prefix_match_len` - How many leading positions of `prompt` a `prefix_attach` would attach right now, attaching nothing: a probe for a caller deciding what a request must bring (a media span's rows).
 - `prefix_release` - Release every cached page back to `pool` and clear the cache (pages still used by live sessions stay alive until those sessions release them).
 
 ### Tokenizer
@@ -3198,8 +3202,10 @@ CPU large-language-model inference in pure daslang: load a GGUF model, tokenize,
 - `eval` - THE eval primitive: run `tokens` at the session's current position and advance it.
 - `eval_batch` - One synchronous batched decode step: row i evals `tokens[i]` at `sessions[i]`'s current position, advancing each by one — B conversations through ONE pass of the weights (GEMVs batch into GEMMs).
 - `eval_embd` - `eval`'s embedding-input twin: prefill `npos` pre-built embedding rows (`npos × dim`, token-major) at the session's current position and advance it — the multimodal splice entry.
+- `eval_embd_body` - Prefill `npos` rows built by `media_body_rows`: [span_lo, span_hi) a non-causal span (empty = every row causal), roped on a merged image `grid` where one is given.
 - `eval_embd_span` - `eval_embd` for a prompt carrying one NON-CAUSAL image span: rows `[span_lo, span_hi)` prefill with every query attending the whole span, the text around them causally — the gemma vision decode shape (non-causal media chunk).
 - `eval_embd_span_mrope` - `eval_embd_span`'s qwen mrope twin: the span rows rope as a `grid`-shaped merged image (position advance `max(grid.x, grid.y)`, tracked on the session for every later eval); same span mask, only the angles differ.
+- `media_body_rows` - One prefill body's rows for `eval_embd_body` on `session`: `head` text, `n_media` media rows of width `src_w`, `tail` text.
 - `sample` - Sample the next token from `session.logits` per `params`: penalties, then temperature/top-k/top-p/min-p and a CDF draw — or greedy argmax when `params.temp <= 0` (`SamplingParams()` defaults are greedy).
 - `set_seed` - Seed the session's sampling RNG for reproducible generation.
 - `stats` - Timing of the most recent `generate`/`respond` call on `session`: prompt/generated token counts, time to first token, prefill and generation tok/s.
@@ -3223,18 +3229,20 @@ CPU large-language-model inference in pure daslang: load a GGUF model, tokenize,
 - `add_assistant` - Inject a KNOWN assistant reply (no generation): prefill the pending user turn and `text` into the KV cache, then close the turn — like `respond` but with a supplied reply.
 - `add_user` - Queue a user message for the next `respond`.
 - `add_user_audio` - Queue audio (16 kHz mono f32 PCM) for the next `respond` — encoded to soft tokens immediately and spliced at the head of the turn before any `add_user` text.
-- `add_user_audio_rows` - Queue PRE-ENCODED audio soft-token rows (what `encode_audio` emits — `dim`-wide on every family, length-checked) for the next `respond`.
+- `add_user_audio_rows` - Queue PRE-ENCODED audio soft-token rows (what `encode_audio` emits — `dim`-wide, length-checked) for the next `respond`.
 - `add_user_image` - Queue an image for the next `respond` — geometry, letterbox and the embedder run NOW, spliced at the head of the next user turn.
 - `add_user_image_rows` - Queue PRE-ENCODED image soft-token rows (what `encode_image` emits — deepstack models: `(1+n)·dim`-wide, length-checked) with the family's mrope `grid` ((0,0) = sequential) for the next `respond`.
+- `add_user_span` - Mark the pending user turn as carrying a media span inline: `render_turn` and `render_assistant` then lay `n_rows` position ids (`media_position_id` over the media's content `key`) where the media sits, `text_before` bytes into the turn's text.
 - `create_chat` - Start a conversation over `model`: resolves the chat template (GGUF-embedded, falling back to the arch registry) and creates the session.
 - `create_chat_renderer` - `create_chat`'s RENDER-ONLY twin: resolves the template/stop ids/turn close but creates NO KV session — a queued request can render its whole prompt holding tokens only, no cache memory.
 - `render_assistant` - `add_assistant`'s render half: appends the exact token stream a known reply prefills to `out` WITHOUT running the model, advancing the transcript like `add_assistant`.
 - `render_close` - The tokens that TERMINATE an assistant turn (what `respond` evals after the reply) — for schedulers that close a finished stream's turn themselves.
 - `render_turn` - Render the next turn's prefill token ids — BOS + system on the first turn, then the user turn and the generation prompt — WITHOUT running the model.
 - `render_turn_audio` - `render_turn`'s AUDIO twin: the same two-span contract around the audio soft-token splice (the template's audio span markers).
-- `render_turn_image` - `render_turn`'s IMAGE twin: the turn's prefill as the two token spans that bracket the image soft-token splice — `head` before the rows, `tail` after.
+- `render_turn_image` - `render_turn`'s IMAGE twin: the two token spans that bracket the image soft-token splice — `head` before the rows, `tail` after.
 - `render_turn_marked` - `render_turn` with its opening marked: `opening` leading tokens - BOS, prelude and the system turn of a conversation's first turn - are the same for any user text, so a prefix cache can checkpoint there.
 - `respond` - Generate the assistant's reply to the queued user message, streaming pieces through the trailing block (return `false` to stop early).
+- `set_chat_date` - Pin the date a Llama-3.1+ system turn states (`"26 Jul 2024"`); `""` returns it to the day the turn renders.
 - `set_thinking` - Toggle reasoning for a hybrid thinking model (Qwen3 family): `false` appends the template's empty think block so the model answers directly.
 
 ### Tool calling
diff --git a/src/simulate/simulate_gc.cpp b/src/simulate/simulate_gc.cpp
index 87d919d423..5521bc6b87 100644
--- a/src/simulate/simulate_gc.cpp
+++ b/src/simulate/simulate_gc.cpp
@@ -217,8 +217,7 @@ namespace das
             if ( currentRange.empty() ) return true;
             if ( currentRange.contains(r) ) return false;
             if ( heapOnly ) {
-                int ssize = int(r.to-r.from);
-                ssize = (ssize + 15) & ~15;
+                uint64_t ssize = (uint64_t(r.to-r.from) + 15) & ~uint64_t(15);
                 return context->heap->isOwnPtr(r.from, ssize);
             }
             return true;
@@ -706,8 +705,7 @@ namespace das
             bool result = true;
             ptrRangeStack.push_back(currentRange);
             if ( !r.empty() && !currentRange.contains(r) ) {
-                int ssize = int(r.to-r.from);
-                ssize = (ssize + 15) & ~15;
+                uint64_t ssize = (uint64_t(r.to-r.from) + 15) & ~uint64_t(15);
                 if ( validate ) {
                     if ( context->heap->isOwnPtr(r.from, ssize) ) {
                         if ( context->heap->isValidPtr(r.from, ssize) ) {
diff --git a/tests/dasHV/test_sse.das b/tests/dasHV/test_sse.das
index ae766450b9..fe4726aa61 100644
--- a/tests/dasHV/test_sse.das
+++ b/tests/dasHV/test_sse.das
@@ -37,6 +37,12 @@ class SseTestServer : HvWebServer {
             set_header(resp, "Content-Type", "text/event-stream")
             return resp |> TEXT_PLAIN(sse_format(string(req.body), "echo"))
         }
+        // a streamed answer: events, then the close - no Content-Length on it
+        STREAM("/streamed") <| @(var req : HttpRequest?; var writer : HttpResponseWriter?) {
+            sse_event(server, writer, "one", "message")
+            sse_event(server, writer, "two", "message")
+            close_writer(server, writer)
+        }
         // Plain text endpoint
         GET("/plain") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
             return resp |> TEXT_PLAIN("hello plain")
@@ -51,6 +57,15 @@ class SseTestServer : HvWebServer {
 [test]
 def test_sse_basic(t : T?) {
     with_test_server(type<SseTestServer>) $(base_url) {
+        t |> run("get_body_bytes sizes a body by the body: a streamed answer carries no Content-Length") @(t : T?) {
+            GET("{base_url}/streamed") $(var resp) {
+                var bytes <- get_body_bytes(resp)
+                t |> equal(resp.content_length, 0)
+                t |> equal(length(bytes), length(resp.body))
+                t |> success(!empty(bytes), "the streamed body arrived ({length(bytes)} bytes)")
+                delete bytes
+            }
+        }
         t |> run("SSE endpoint returns event-stream content type") @(t : T?) {
             GET("{base_url}/events") $(var resp) {
                 t |> equal(int(resp.status_code), int(http_status.OK))
diff --git a/tests/gc/test_gc_borrowed_4gib.das b/tests/gc/test_gc_borrowed_4gib.das
new file mode 100644
index 0000000000..2ba441d2d5
--- /dev/null
+++ b/tests/gc/test_gc_borrowed_4gib.das
@@ -0,0 +1,23 @@
+// A borrowed array view (a mapped file plane) whose byte length is a whole multiple of 4 GiB: the mark walk sizes
+// the range in 64 bits. Sized in 32, the range read as empty and the validating collect indexed the heap's chunk
+// table by it.
+options gen2
+options persistent_heap
+options gc
+options no_aot   // the test calls heap_collect with its `T?` argument live, and AOT refuses a function whose frame the collector must walk (error 50503)
+
+require dastest/testing_boost public
+
+var g_backing : uint64[16]   // global memory, outside the heap, as a mapping is
+var g_plane : array<uint64>
+
+[test]
+def test_gc_borrowed_range_of_4gib(t : T?) {
+    let n = 1l << 29l   // 2^29 uint64 = 4 GiB of range over 16 real elements; the walk reads no element of a uint64 array
+    unsafe {
+        _builtin_make_temp_array_i64(g_plane, addr<void?>(g_backing[0]), n)
+        heap_collect(true, true)
+    }
+    t |> equal(long_length(g_plane), n, "the view survives a validating collect")
+    unsafe(_builtin_forget_temp_array(g_plane))
+}
diff --git a/tutorials/dasLLAMA/02_chat.das b/tutorials/dasLLAMA/02_chat.das
index 9b034ea099..3495d46dbb 100644
--- a/tutorials/dasLLAMA/02_chat.das
+++ b/tutorials/dasLLAMA/02_chat.das
@@ -4,6 +4,7 @@ options stack = 524288   // every dasLLAMA program root takes this budget (optio
 require dasllama/dasllama
 require daslib/fio
 require strings
+require daslib/strings_boost
 
 // Tutorial dasLLAMA-02: Chat and Templates
 //
@@ -13,6 +14,7 @@ require strings
 //   - The transcript: chat.history
 //   - Under the hood: chat templates and render_turn
 //   - Replaying history: add_assistant and render_assistant
+//   - Pinning the date a Llama-3.1+ system turn states: set_chat_date
 //
 // Prerequisites: tutorial 01; a chat-tuned GGUF (SmolLM2-135M-Instruct works).
 //
@@ -119,6 +121,7 @@ def main() {
         print("\n")
 
         section_replay(m, chat)
+        section_date(m)
     }
 }
 
@@ -155,3 +158,27 @@ def section_replay(m : Model; chat : ChatSession) {
     render_assistant(m, rchat, "Paris.", replay_toks)
     print("one replayed exchange = {length(replay_toks)} tokens, rendered without touching the model\n")
 }
+
+// ──────────────────────────────────────────────────────────────────────────
+// Section 6 — A dated system turn: set_chat_date
+// ──────────────────────────────────────────────────────────────────────────
+//
+// The Llama-3.1+ template writes two lines into every system turn: the
+// model's knowledge cutoff and today's date. Today's date changes the prompt
+// every midnight, so a test that compares token streams, or a benchmark with
+// a fixed prompt, pins it with set_chat_date. "" gives the clock back. A
+// template that states no date (ChatML, gemma) ignores the pin.
+
+def section_date(m : Model) {
+    set_chat_date("26 Jul 2024")
+    var rchat = create_chat_renderer(m, SYSTEM)
+    add_user(rchat, "What day is it?")
+    let text = decode(m, render_turn(m, rchat))
+    set_chat_date("")
+    let dated <- [for (line in split(text, "\n")); line; where find(line, "Date:") >= 0]
+    if (empty(dated)) {
+        print("\nthis template states no date - set_chat_date leaves its turns as they were\n")
+    } else {
+        print("\nthe pinned system turn states: {dated}\n")
+    }
+}
diff --git a/tutorials/dasLLAMA/08_audio_chat.das b/tutorials/dasLLAMA/08_audio_chat.das
index 7307b070a7..ea7e167b13 100644
--- a/tutorials/dasLLAMA/08_audio_chat.das
+++ b/tutorials/dasLLAMA/08_audio_chat.das
@@ -14,7 +14,8 @@ require math
 //   - Audio towers: load_audio_tower reads a multimodal projector (mmproj) GGUF
 //   - create_chat(model, tower) — a conversation that can hear
 //   - add_user_audio + add_user composing one turn; respond() streams the reply
-//   - add_user_audio_rows: pre-encoded carrier rows onto a plain chat (the gemma-4 E-series rail)
+//   - add_user_audio_rows: pre-encoded carrier rows onto a plain chat (the only chat rail for gemma-4 E-series)
+//   - add_user_span + media_body_rows + eval_embd_body: the audio in its place, prefilled as one body
 //   - caps(model) — LlmCaps, the chat layer's honesty contract
 //
 // Audio-capable chat models pair a normal text decoder with a whisper-family audio
@@ -27,8 +28,9 @@ require math
 // The chat template picks the audio framing automatically (qwen2 family wraps the span
 // in <|audio_bos|>/<|audio_eos|>, llama-3 splices bare embeddings, voxtral opens with
 // [BEGIN_AUDIO]) — the calls below are identical for every pair.
-// Qwen3-Omni and Gemma-4 E-series audio are served too, but through the ASR surface
-// (tutorial 07's two-path load_asr_model), not load_audio_tower.
+// Qwen3-Omni and Gemma-4 E-series audio are served too, but not by load_audio_tower:
+// tutorial 07's two-path load_asr_model transcribes them, and a Gemma-4 E-series pair
+// chats here through the AudioEmbedder carrier rail at the end of this file.
 //
 // Prerequisites: a decoder GGUF + its mmproj GGUF + a 16 kHz mono PCM16 WAV.
 //
@@ -89,25 +91,29 @@ def section_render_spans(m : Model; prompt : string) {
 }
 
 // And the rows themselves: the AudioEmbedder carrier is the family-neutral encoder a
-// scheduler owns — probe the mmproj first (0 = no carrier-served audio tower; the
-// load_audio_tower families above are served by the chat's own tower instead), then
-// load_audio_embedder + encode_audio turn the PCM into the soft-token rows that splice
-// between the two spans. The pre-encoded-rows seam closes the loop: add_user_audio_rows
-// moves those rows onto a PLAIN chat (no tower attached) and respond() runs the spliced
-// turn - the shape a scheduler that owns its encoder uses, and how a carrier-served
-// family hears at the chat layer at all.
-def section_carrier_encode(m : Model; mmproj_path : string; samples : array<float>; prompt : string) {
+// scheduler owns. It serves every audio mmproj this tutorial takes - the
+// load_audio_tower families and the gemma-4 E-series alike - and audio_probe_proj_dim
+// answers 0 only for a file no audio family serves. load_audio_embedder + encode_audio
+// turn the PCM into the soft-token rows that splice between the two spans. The
+// pre-encoded-rows seam closes the loop: add_user_audio_rows moves those rows onto a
+// PLAIN chat (no tower attached) and respond() runs the spliced turn - the shape a
+// scheduler that owns its encoder uses, and how a gemma-4 E-series pair hears at the
+// chat layer at all. audio_span_bare says whether the span takes markers: an ultravox
+// span sits bare in a stock Llama template, which knows no audio marker.
+def section_carrier_encode(m : Model; mmproj_path : string; audio_path : string; samples : array<float>; prompt : string) {
     if (audio_probe_proj_dim(mmproj_path) == 0l) {
-        print("carrier: {mmproj_path} carries no carrier-served audio tower (gemma4a) - skipping the encode demo\n")
+        print("carrier: no audio family serves {mmproj_path} - skipping the encode demo\n")
         return
     }
     var inscope e <- load_audio_embedder(mmproj_path)
     var st = AudioState()
     var rows : array<float>
     let n = encode_audio(e, st, samples, rows)
-    print("encode_audio ({audio_family(e)}): {float(length(samples)) / 16000.0}s -> {n} soft tokens x {audio_proj_dim(e)} wide\n")
+    let bare = audio_span_bare(e)
+    print("encode_audio ({audio_family(e)}): {float(length(samples)) / 16000.0}s -> {n} soft tokens x {audio_proj_dim(e)} wide, bare span: {bare}\n")
     var chat <- create_chat(m, "", 96l)
-    add_user_audio_rows(m, chat, rows, n)   // moves the rows in; the turn renders its audio span around them
+    var chat_rows := rows
+    add_user_audio_rows(m, chat, chat_rows, n, bare)   // moves the rows in; the turn renders its audio span around them
     add_user(chat, prompt)
     print("carrier chat > {prompt}\n")
     respond(m, chat, SamplingParams()) $(piece_text) {
@@ -117,6 +123,59 @@ def section_carrier_encode(m : Model; mmproj_path : string; samples : array<floa
     print("\n\n")
     delete chat
     delete st
+    section_inline_body(m, hash(audio_path), rows, n, bare, prompt)
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Section 4 — The audio in its place: one prefill body by hand
+// ──────────────────────────────────────────────────────────────────────────
+//
+// So far the audio led the turn. add_user_span puts it where it sits in the
+// message: text_before bytes into the turn's text. The span carries the
+// media's content key - the same clip, the same key - and render_turn then
+// lays n_rows media position ids where the rows go: negative numbers no vocab
+// id uses, so a prefix cache matches across the span as it does across text.
+//
+// A program that owns its encoder and scheduler prefills that turn as ONE
+// body instead of three evals (text, rows, text). media_body_rows builds the
+// body's rows - head text, the media rows, tail text - and eval_embd_body
+// prefills them. An empty span (0, 0) keeps every row causal, as audio wants;
+// an image passes its span and its grid. On a gemma-4 E-series decoder the
+// session also takes each text row's token id, so text rows get their own
+// per-layer input; eval_embd_body spends the ids.
+def section_inline_body(m : Model; key : uint64; rows : array<float>; n : int64; bare : bool; prompt : string) {
+    let lead = "Here is a recording. "
+    var rchat <- create_chat_renderer(m, "", 64l)
+    add_user(rchat, "{lead}{prompt}")
+    add_user_span(m, rchat, key, n, length(lead), false, bare)
+    var inscope turn <- render_turn(m, rchat)
+    var lo = 0l
+    while (!is_media_position(turn[lo])) {
+        lo ++
+    }
+    var inscope head <- [for (k in range64(lo)); turn[k]]
+    var inscope tail <- [for (k in range64(lo + n, long_length(turn))); turn[k]]
+    print("add_user_span: {long_length(head)} text tokens | {n} media ids | {long_length(tail)} text tokens\n")
+    var s <- create_session(m)
+    var body : array<float>
+    media_body_rows(m, s, head, rows, n, m.config.dim, tail, body)
+    eval_embd_body(m, s, body, long_length(turn), 0l, 0l, int2(0))
+    print("one body > {lead}<audio>{prompt}\n")
+    let stop_ids <- turn_stop_ids(rchat)
+    var guard <- make_nothink_guard(rchat)
+    var one <- [0l]
+    for (_step in range64(64l)) {
+        let tok = sample(s, SamplingParams())
+        let text = piece(m, tok)
+        break if (find_index(stop_ids, tok) >= 0 || nothink_stop_here(guard, tok, text))
+        print("{text}")
+        one[0] = tok
+        eval(m, s, one)
+    }
+    print("\n\n")
+    delete body
+    delete s
+    delete rchat
 }
 
 // Minimal RIFF/WAVE reader for 16-bit PCM mono 16 kHz input — enough for the tutorial;
@@ -185,21 +244,20 @@ def main {  // nolint:STYLE038 - one linear tutorial walkthrough; the carrier ra
     // the pair must match: the tower projects into the decoder's embedding width, and
     // create_chat panics on a mismatched pair rather than degrading.
     //
-    // Two rails, decided by the mmproj: a carrier-served file (the gemma-4 E-series —
-    // audio_probe_proj_dim answers its width) demos the scheduler-side carrier path and
-    // returns, because load_audio_tower does not serve that family; every load_audio_tower
-    // pair takes the chat rail below.
+    // Two rails, decided by the mmproj: a file load_audio_tower serves
+    // (audio_tower_probe_proj_dim answers its width) runs every section below; any other
+    // file - the gemma-4 E-series - demos only the scheduler-side carrier path and returns.
     var m <- load_model(ggufs[0], QuantMode.q8)
     m.config.seq_len = min(m.config.seq_len, 4096l)
-    if (audio_probe_proj_dim(ggufs[1]) > 0l) {
+    if (audio_tower_probe_proj_dim(ggufs[1]) == 0l) {
         allow_cpu_prefill()
         let carrier_samples <- read_wav_pcm16_mono(audio_path)
         with_job_que() {
             setup_dasllama_jobque()
             section_render_spans(m, prompt)
-            section_carrier_encode(m, ggufs[1], carrier_samples, prompt)
+            section_carrier_encode(m, ggufs[1], audio_path, carrier_samples, prompt)
         }
-        print("this mmproj serves through the AudioEmbedder carrier (the server rail) - the create_chat sections need a load_audio_tower pair (qwen2a / omni / ultravox / voxtral)\n")
+        print("this mmproj serves through the AudioEmbedder carrier only - the create_chat sections need a load_audio_tower pair (qwen2a / omni / ultravox / voxtral)\n")
         return
     }
     var tower <- load_audio_tower(ggufs[1])
@@ -248,5 +306,6 @@ def main {  // nolint:STYLE038 - one linear tutorial walkthrough; the carrier ra
 
         section_splice(m)
         section_render_spans(m, prompt)
+        section_carrier_encode(m, ggufs[1], audio_path, samples, prompt)
     }
 }
diff --git a/tutorials/dasLLAMA/15_prefix_cache.das b/tutorials/dasLLAMA/15_prefix_cache.das
index b501d687c4..d709a46ddb 100644
--- a/tutorials/dasLLAMA/15_prefix_cache.das
+++ b/tutorials/dasLLAMA/15_prefix_cache.das
@@ -11,6 +11,7 @@ require strings
 // This tutorial covers:
 //   - create_prefix_cache over one create_kv_pool pool
 //   - prefix_insert: a finished stream donates its KV pages
+//   - prefix_match_len: how much of a prompt the cache holds, attaching nothing
 //   - prefix_attach: the next request skips the donated prefill
 //   - prefix_chain_list + prefix_held_groups: what the cache holds
 //   - render_turn_marked + prefix_checkpoint_at: models that carry state between tokens
@@ -42,6 +43,10 @@ let PAGE_ROWS = 16l
 // prefix_insert. `tokens` is A's full evaled history — the cache keeps every
 // full page of it. The preview string is only a label for dashboards.
 //
+// Before B takes anything, prefix_match_len asks the cache how many of B's
+// leading tokens it holds. It attaches nothing and touches no entry - a
+// caller uses it to decide what a request must still bring.
+//
 // Stream B starts FRESH from the same pool. prefix_attach walks B's prompt
 // against the cached chains: matched pages join B's page table, B's n_past
 // jumps past them, and we prefill only the tail. The match is capped one
@@ -57,6 +62,7 @@ def section_donate_attach(m : Model; var pool : KVPool; var cache : PrefixCache)
     delete s1
 
     let p2 <- encode(m, "{SYSTEM}{Q2}")
+    print("prefix_match_len: the cache holds {prefix_match_len(cache, pool, p2)} of B's leading tokens\n")
     var s2 = create_session(m, pool)
     let matched = prefix_attach(cache, pool, s2, p2)
     let total = long_length(p2)
diff --git a/utils/dasllama-server/README.md b/utils/dasllama-server/README.md
index d77b99ffb7..394ea9328d 100644
--- a/utils/dasllama-server/README.md
+++ b/utils/dasllama-server/README.md
@@ -171,7 +171,7 @@ run blocks until the clip ends; a box with no device says so and keeps writing t
 `--models-dir` (`~/.dasllama/models`, where the catalog downloads land). The `dasllama-server.toml`
 in the current directory, else in `~/.dasllama`, else beside the program - the server's own lookup - fills whatever
 the flags leave empty - the
-model (a `[[models]]` roster's default entry included), its `image_mmproj`, the `asr` and `tts`
+model (a `[[models]]` roster's default entry included), its `image_mmproj` and `audio_mmproj`, the `asr` and `tts`
 models (an `[[asr]]` / `[[tts]]` roster's first table), the backend, the lane cap - so on a box the setup page configured, `dasllama-cli chat`
 with no flags talks to the served model on the served backend; explicit flags win, `--config`
 names another file. The answer goes to stdout alone, so it pipes; the CLI's progress lines and
@@ -187,7 +187,7 @@ tree it keeps its own tune sidecar beside `cli.das`.
 ```sh
 bin/daslang -jit utils/dasllama-server/main.das -- --model <model.gguf> [--port 8080] [--quant q8] \
                                                     [--asr <asr.bin>] [--asr-workers 2] [--mmproj <mmproj.gguf>] \
-                                                    [--image-mmproj <mmproj.gguf>] [--ctx 4096] \
+                                                    [--image-mmproj <mmproj.gguf>] [--audio-mmproj <mmproj.gguf>] [--ctx 4096] \
                                                     [--streams 4] [--chunk 512] [--chunk-idle 2048] [--page-rows 64] [--prefix N]
 ```
 
@@ -214,7 +214,8 @@ Run under `-jit` - the interpreter is refused, it is far too slow for inference.
 | `--tts` | - | - | TTS model GGUF (`kitten-nano`, `kitten-mini`, `kokoro-82m`, with the front-end packs `tts_g2p.bin` + `tts_postag.bin` beside them; or a `pocket-tts-<lang>-q8` file, which reads text, needs no pack and clones a voice) - enables `/v1/audio/speech`. Repeatable: each model serves under its file's stem, the first is the default (`--tts-lane` and `--tts-voices-dir` are the first one's); the config's `[[tts]]` tables give each model its own `id`, `lane` and `voices_dir` |
 | `--tts-lane` | - | `q8` | Weight lane the speech worker pins around its load: `q8` (the prepared quant image beside the GGUF) or `f32` (the file's own planes - the reference lane). An unknown spelling warns and serves `q8`. With several TTS models, the first one's |
 | `--tts-voices-dir` | - | - | Directory of voice clips (wav / flac / mp3 / ogg, a few seconds of one speaker each, 60 s at most) a cloning speech model adds to its voices at boot (with several TTS models, the first one's), each under its file's stem (`mine.wav` -> voice `mine`; a stem the model already carries replaces that voice, with a log line). A clip that does not decode or runs past 60 s is logged and skipped; the key on a model that cannot clone is logged and ignored |
-| `--image-mmproj` | - | - | Vision mmproj (gemma4uv, gemma4v, or gemma3v, sniffed) for the default model - enables `image_url` parts on `/v1/chat/completions`. Per-model in a `[[models]]` roster: `image_mmproj = "..."`. When the file also carries a gemma4a audio encoder (the E-series mmproj carries both towers), the same flag arms **native audio**: `input_audio` parts serve through the same slot - one decoder, one mmproj, no dedicated ASR model copy |
+| `--image-mmproj` | - | - | Vision mmproj (gemma4uv, gemma4v, or gemma3v, sniffed) for the default model - enables `image_url` parts on `/v1/chat/completions`. Per-model in a `[[models]]` roster: `image_mmproj = "..."`. When the file also carries an audio encoder (the gemma-4 E-series and the Qwen Omni mmprojs carry both towers), the same flag arms **native audio**: `input_audio` parts serve through the same slot - one decoder, one mmproj, no dedicated ASR model copy |
+| `--audio-mmproj` | - | - | Audio mmproj for the default model - enables `input_audio` parts on `/v1/chat/completions`: a whisper-class tower with its projector (Qwen2-Audio, Qwen2.5-Omni, Ultravox, Voxtral) or the gemma-4 Conformer. Per-model in a `[[models]]` roster: `audio_mmproj = "..."`. Not needed when `--image-mmproj` names a file that carries the audio tower too |
 | `--ctx` | - | *model* | Context length in tokens, served whole: the whole-model GPU driver holds it for every stream or declines to the per-op rails, and the load log names the room. Default: the model's trained `context_length`, shortened to what the card holds (the log says by how much and why). A Metal model served from its image alone (no host weights) is cut to the rows its device KV mirror holds (`DASLLAMA_METAL_KV_MIRROR_MB`), with a warning - a boot load and a live `/v1/models/load` alike. |
 | `--max-tokens` | - | `16384` | Default reply token budget when a request omits `max_tokens` (clamped to `--ctx` per request) |
 | `--streams` | `-s` | `4` | Max concurrent generation streams |
@@ -285,7 +286,7 @@ table's value, as a flag overrides any key of a config that is not authoritative
 ## Setup mode and the model catalog
 
 A start with **no LLM model at all** (no `--model`, no config, or every configured path
-missing) **and no servable `--tts`** does not exit - it boots into **setup mode**: the port
+missing) **and no servable `--tts` or `--asr`** does not exit - it boots into **setup mode**: the port
 opens, the control page serves, every inference route answers with a clean error, and the
 page leads with the **model catalog** (sec. 03) - a curated, sha-pinned list of current models
 (`model_catalog.das`; commit-pinned
@@ -297,9 +298,14 @@ model** - the page writes the config and restarts (exit 4, the watchdog contract
 into serving it. The same catalog stays available on a serving server for pulling more
 models.
 
-**`--tts` alone is a serving start, not a setup start.** A speech-only server has no LLM slot,
-so `/v1/stats` answers the slotless shape - but its `setup` reads `false`, and the page keeps
-its serving surface instead of leading with the catalog.
+**`--tts` or `--asr` alone is a serving start, not a setup start.** A speech-only server has no
+LLM slot, so `/v1/stats` answers the slotless shape - but its `setup` reads `false`, its ASR and
+TTS counters are live, and the page keeps its serving surface instead of leading with the catalog.
+
+**An ASR model whose decoder is an LLM decodes where the server's LLMs do.** A two-file model
+(`--asr` with `--mmproj`: Qwen3-ASR, Canary, the gemma audio route) takes the boot's Metal mode in
+its worker; a one-file model (whisper, parakeet) decodes on the CPU. `/v1/stats` says which under
+`asr.models[]` - `id`, `workers`, `ready`, and `decoder` (`metal` or `cpu`).
 
 **A `--tts` the server cannot serve degrades, it does not die.** A missing file (the GGUF, or
 `tts_g2p.bin` / `tts_postag.bin` beside it) is logged as an error before the worker starts, and
@@ -458,9 +464,9 @@ DLLs; the config and the bundle's tune state live in `~/.dasllama` and survive t
 | `GET`  | `/` | Control page: live stats + charts, models panel (per-slot cards with state/GPU badges, prefix hit rate, switch telemetry, activate buttons; VRAM bar + switch strip), stream swimlane + live text cards, prefix-cache table, a chat panel (all sampling knobs, `<think>` inline, mic input - dictation under `--asr`, else the clip attaches to the next message when the slot serves native audio; under `--tts` every answer wears a speaker button that reads its content half back on the studio's voice, split at sentence boundaries into pieces the speech route accepts), a speech studio (type a line, hear it, and read the front end's normalized text and per-chunk phonemes under the waveform), config editor with the `[[models]]` roster table + save/restart, GC + drain buttons. Serves `control.html` from beside the server sources - polls `/v1/stats` + `/v1/streams` at 1 Hz |
 | `GET`  | `/v1/models` | Lists every served slot, every TTS model under its id, and the ASR models: the default one as `<default slot>-asr` beside an LLM, and each under its own id when several serve or no LLM does - requests route on these ids via their `"model"` field |
 | `POST` | `/v1/models/activate` | `{"model": name}` loopback-only admin warm-switch: make `name` the DEFAULT + stepped slot (model-less page requests follow) and move the GPU tier to it now (instead of waiting for the owner to drain). `409` while any work is live, `404` on an unknown name; `200` reports `switch_ms` + `backend_effective` |
-| `POST` | `/v1/models/load` | `{"path", "id"?, "backend"?: "auto"\|"cpu", "quant"?, "ctx"?, "image_mmproj"?, "activate"?: true}` loopback-only live load: a downloaded GGUF joins as a NEW serving slot with no restart and no JIT recompile (the load blocks the tick for its duration; a prepared `.dlim` image loads in well under a second). `"auto"` follows the boot GPU policy - same want + `--ctx` clamp every boot load got, the current owner's VRAM state drops first (boot-order semantics) and re-arms if the load fails or stays off the device; `"ctx"` in the body replaces the boot `--ctx`, and is asked whole the same way. An `image_mmproj` arms vision (and audio, when the file carries the gemma4a tower) with a media-worker bounce - a bad mmproj degrades to text-only with the reason in `tower_note`, and a load panic (corrupt GGUF, refused KV geometry) answers `400` with the slot unwound. `409` on a live stream set, a taken id, or a GGUF another slot already serves (one slot per file) |
+| `POST` | `/v1/models/load` | `{"path", "id"?, "backend"?: "auto"\|"cpu", "quant"?, "ctx"?, "image_mmproj"?, "audio_mmproj"?, "activate"?: true}` loopback-only live load: a downloaded GGUF joins as a NEW serving slot with no restart and no JIT recompile (the load blocks the tick for its duration; a prepared `.dlim` image loads in well under a second). `"auto"` follows the boot GPU policy - same want + `--ctx` clamp every boot load got, the current owner's VRAM state drops first (boot-order semantics) and re-arms if the load fails or stays off the device; `"ctx"` in the body replaces the boot `--ctx`, and is asked whole the same way. An `image_mmproj` arms vision (and audio, when the file carries an audio tower too), an `audio_mmproj` arms audio alone, each with a media-worker bounce - a bad mmproj degrades to text-only with the reason in `tower_note`, and a load panic (corrupt GGUF, refused KV geometry) answers `400` with the slot unwound. `409` on a live stream set, a taken id, or a GGUF another slot already serves (one slot per file) |
 | `POST` | `/v1/models/unload` | `{"model": name}` loopback-only: free the slot's weights, KV pool, and (for the GPU owner) VRAM. The DEFAULT slot refuses (`400`) - activate another model first - which also keeps the last model serving. `409` while any work is live |
-| `POST` | `/v1/chat/completions` | Chat; `stream: true` -> SSE, else buffered; OpenAI function calling (`tools`); `image_url` content parts under `--image-mmproj`; `input_audio` content parts when the mmproj carries the audio tower (one image OR one audio clip per request, on the final user message - the soft tokens splice into the serving slot's prefill like vision, so continuous batching covers audio too). A stream sent with `stream_options: {"include_usage": true}` ends, before `[DONE]`, on one chunk with an empty `choices` list: `usage` (`prompt_tokens`, `completion_tokens`, `total_tokens`, and `prompt_tokens_details.cached_tokens` - the prompt tokens the prefix cache attached) and `timings` (`ttft_ms`, the scheduler's admit-to-first-token wall, and `gen_ms`, first token to finish); a stream that does not ask carries no such chunk |
+| `POST` | `/v1/chat/completions` | Chat; `stream: true` -> SSE, else buffered; OpenAI function calling (`tools`); `image_url` content parts under `--image-mmproj`; `input_audio` content parts under `--audio-mmproj`, or when the image mmproj carries the audio tower (any user message may carry images and clips, up to 16 parts a request - each splices into the serving slot's prefill where the part sits among its message's text parts, so continuous batching covers audio too; a part is encoded and prefilled once: a continued chat, or the same request again, attaches its span off the prefix cache and never reaches the tower). A known part goes to the scheduler with no rows only where the prefix cache holds its span when the request is submitted; a span the cache drops before the stream's admission makes the server encode every part of the request and submit it again, once, and where that retry cannot be made the reply finishes with `finish_reason` `"media_lost"`. A stream sent with `stream_options: {"include_usage": true}` ends, before `[DONE]`, on one chunk with an empty `choices` list: `usage` (`prompt_tokens`, `completion_tokens`, `total_tokens`, and `prompt_tokens_details.cached_tokens` - the prompt tokens the prefix cache attached) and `timings` (`ttft_ms`, the scheduler's admit-to-first-token wall, and `gen_ms`, first token to finish); a stream that does not ask carries no such chunk |
 | `POST` | `/v1/completions` | Raw completion; `stream: true` -> SSE, else buffered; the same `stream_options.include_usage` closing chunk as the chat route |
 | `POST` | `/v1/embeddings` | Mean-pooled, L2-normalized sentence embeddings |
 | `POST` | `/v1/audio/transcriptions` | Speech->text (multipart upload; needs `--asr`). One ASR model takes every request, whatever `model` says; with several, `model` names one by its id (none, or the `<default slot>-asr` id `/v1/models` lists: the first; any other name: `404`); `language` defaults to English, and to detection on a model that only detects. `response_format=verbose_json` adds timed segments |
@@ -475,7 +481,7 @@ DLLs; the config and the bundle's tune state live in `~/.dasllama` and survive t
 | `POST` | `/bake` | `{"model"?: name}` loopback-only: bake the slot's prepared `.dlim` image by spawning `dasllama-convert` (empty body bakes the default slot; 409 while a bake or bench runs or streams are active; the dlim GC of never-loadable images runs on completion) |
 | `GET`  | `/bake` | Bake state (`idle | running | done | failed`), the slot it runs for, log lines, the result JSON |
 | `GET`  | `/v1/images` | Per-slot prepared-image inventory: source GGUF path, the flavor THIS process mapped (planar/vulkan/metal, or raw gguf), the trimmed flag, and each on-disk `.dlim`'s info - plus the slot name a bake is currently running for |
-| `GET`  | `/v1/stats` | Scheduler counters (`gen_tokens`, `prefill_tokens`, TTFT last/avg, ...) plus `model`/`active_model`/`ctx`/`uptime_s`/`draining` identity fields, memory footprint (`weights_bytes`, `kv_bytes`, das heaps, `gpu_vram_bytes`/`gpu_budget_bytes`), `gpu_cpu_passes` (the calls the armed GPU path handed back to the CPU since the model armed, `{reason, words, count}` per reason that fired - `words` is the reason as the control page prints it; empty means the device served every call), a `hardware` line (CPU * lanes * GPU), `asr_workers`, `asr_ready`, `asr_active`, `asr_pending`, speech counters (`tts_done_jobs` - syntheses served since boot, `tts_audio_s` - the speech seconds they carried), a `tts` block present ONLY while a speech model is configured - and still there when its worker could not load it; it describes the default TTS model (the first that loaded, else the first that failed), and carries `models` - the ids of every loaded TTS model - only when several serve (`id`, `ready`, `pending`, `done_jobs`, `audio_s`, `voices[]` and `sample_rate` as the loaded model declares them, `cloning` (the model takes a voice from a clip), `speed` (a `speed` other than 1.0 is honoured; false for a Pocket model, which refuses one) and `lang` (the first language it declares), the `lane` its worker pinned or, before there is an answer, the one the boot asked for, and `error` - the loader's reason, present only when the configured model failed to load, which the control page's offer card reads instead of claiming the model is still on its way) - the control page's speech studio gates on `ready`, media counters (`media_pending`, `media_rows`, `mrope_streams` - streams whose media rode the qwen mrope grid walk), and `models[]` - one entry per slot: `file` (source GGUF base name - the page's serve-live gate), `is_active`, `holds_gpu`, requested `backend` vs `backend_effective` (`cpu`/`gpu:rails`/`gpu:resident`), `served` (how the slot is served, in plain words: where the weights sit and where the streams' caches do - the control page prints it on the model card), `served_note` (why it is not served better: the whole-model driver's decline with its remedy, the tower or self-speculation that keeps the caches on the host, fewer K/V regions than streams; empty when nothing holds the slot back), `device_kv` (every stream's K/V cache lives on the GPU, a region each), `vision` and `audio` (the towers that slot actually loaded - the catalog row's chip reads them, and `audio` is what tells the chat mic to attach a clip instead of transcribing it), per-slot cache counters, `last_used_s`, switch count/avg ms |
+| `GET`  | `/v1/stats` | Scheduler counters (`gen_tokens`, `prefill_tokens`, TTFT last/avg, ...) plus `model`/`active_model`/`ctx`/`uptime_s`/`draining` identity fields, memory footprint (`weights_bytes`, `kv_bytes`, das heaps, `gpu_vram_bytes`/`gpu_budget_bytes`), `gpu_cpu_passes` (the calls the armed GPU path handed back to the CPU since the model armed, `{reason, words, count}` per reason that fired - `words` is the reason as the control page prints it; empty means the device served every call), a `hardware` line (CPU * lanes * GPU), `asr_workers`, `asr_ready`, `asr_active`, `asr_pending`, an `asr` block present while an ASR model is configured (`models[]`: each model's `id`, `workers`, `ready` and `decoder` - `metal` where its workers decode on the device, `cpu` elsewhere, empty until a worker answered), speech counters (`tts_done_jobs` - syntheses served since boot, `tts_audio_s` - the speech seconds they carried), a `tts` block present ONLY while a speech model is configured - and still there when its worker could not load it; it describes the default TTS model (the first that loaded, else the first that failed), and carries `models` - the ids of every loaded TTS model - only when several serve (`id`, `ready`, `pending`, `done_jobs`, `audio_s`, `voices[]` and `sample_rate` as the loaded model declares them, `cloning` (the model takes a voice from a clip), `speed` (a `speed` other than 1.0 is honoured; false for a Pocket model, which refuses one) and `lang` (the first language it declares), the `lane` its worker pinned or, before there is an answer, the one the boot asked for, and `error` - the loader's reason, present only when the configured model failed to load, which the control page's offer card reads instead of claiming the model is still on its way) - the control page's speech studio gates on `ready`, media counters (`media_pending`, `media_rows`, `mrope_streams` - streams whose media rode the qwen mrope grid walk), and `models[]` - one entry per slot: `file` (source GGUF base name - the page's serve-live gate), `is_active`, `holds_gpu`, requested `backend` vs `backend_effective` (`cpu`/`gpu:rails`/`gpu:resident`), `served` (how the slot is served, in plain words: where the weights sit and where the streams' caches do - the control page prints it on the model card), `served_note` (why it is not served better: the whole-model driver's decline with its remedy, the tower or self-speculation that keeps the caches on the host, fewer K/V regions than streams; empty when nothing holds the slot back), `device_kv` (every stream's K/V cache lives on the GPU, a region each), `vision` and `audio` (the towers that slot actually loaded - the catalog row's chip reads them, and `audio` is what tells the chat mic to attach a clip instead of transcribing it), per-slot cache counters, `last_used_s`, switch count/avg ms |
 | `GET`  | `/v1/streams` | Per-stream poll surface: `model` (the slot it runs on), state (`queued`/`prefilling`/`decoding`/`finished`), token counts, TTFT, and capped text tails (prompt head + generated tail); finished streams linger ~10 s flagged `finished`. Plus `cache`: the prefix-cache donation chains (tokens, live pages, hits, age, preview) and `asr`: recent ASR jobs (`model` - the id of the ASR model that took the job, empty once its client has gone - state, audio s, wall ms, RTF) |
 | `GET`  | `/config` | Effective config with per-key source (`default`/`cli`/`toml`) - one entry per row of the flags table above, `tts` (the speech model path), `tts_lane` (`q8` | `f32`) and `tts_voices_dir` (the clip directory a cloning model reads) included - plus the `[[models]]` roster, the speech rosters `asr_models` (`id`, `path`, `mmproj`, `workers` an entry) and `tts_models` (`id`, `path`, `lane`, `voices_dir`) - one entry for a one-path `asr` / `tts` key, one a repeated `--asr` / `--tts` flag, one a `[[asr]]` / `[[tts]]` table - model files beside the served one, active rail (gguf vs prepared `.dlim`), GPU tier status (`supported` + `reason` when the loaded model can't ride it). `chunk_idle` answers raw: 0 when unset, meaning the serving backend's default (2048 on Metal, 512 elsewhere) |
 | `POST` | `/config` | Validate a `{key: value}` JSON body (`asr` and `tts` each a path, or an array of entries with the `[[asr]]` / `[[tts]]` table keys) and write it as an **authoritative** TOML (`authoritative = true`) to the config path (or `~/.dasllama/dasllama-server.toml` on a config-less start). Applies on the next restart |
@@ -704,7 +710,7 @@ absent; set `DASLLAMA_MODELS_DIR`):
   `SmolLM2-135M-Instruct-Q8_0.gguf`.
 - `test_openai_server_stream.das` - SSE chunk framing, the over-long-prompt 400, two concurrent
   clients batching on one server (`peak_active >= 2` via `/v1/stats`), mid-generation disconnect
-  eviction, and the prefix cache returning an identical completion for a repeated request; needs
+  eviction, and a request served off the prefix cache repeating itself token for token; needs
   `SmolLM2-135M-Instruct-Q8_0.gguf`.
 - `test_openai_server_vision.das` - the image route end to end: a data-URI photo on
   `/v1/chat/completions` reaches the embedder, splices as soft tokens between the two rendered
@@ -726,8 +732,10 @@ absent; set `DASLLAMA_MODELS_DIR`):
   two ASR models and two TTS models, every id on `/v1/models`, each answering under its own id
   (the job's model read off `/v1/streams`) and the first of a kind answering a request that names
   none, the `404` for an id nothing serves with its upload removed, a model added twice served
-  once, the four answering four requests sent at once, one ASR model taking any name, and an ASR
-  model that cannot load failing the boot. Needs both Qwen3-ASR GGUFs with
+  once, the four answering four requests sent at once, one ASR model taking any name, an ASR
+  model serving alone - its decoder on the CPU with the Metal mode off and on the device with it
+  on, read off `/v1/stats`'s `asr.models[].decoder`, the stats counting its worker and its clip -
+  and an ASR model that cannot load failing the boot. Needs both Qwen3-ASR GGUFs with
   their mmprojs, `kitten-nano.gguf` with the front-end packs, and `pocket-tts-en-q8.gguf`.
 - `test_cli_args.das` - dasllama-cli's model-free half, run everywhere: the plan a command line
   parses to, the bare-token walk, the help surfaces, the config file's keys and roster, the
@@ -777,5 +785,4 @@ and warm-vs-cold TTFT for the prefix cache.
 ## Not yet implemented
 
 The request's `stop` / `response_format` fields and the forced-function `tool_choice` object form
- - all logged when a request carries them. On the media path: more than one media clip per request,
-media on earlier turns of a conversation, and remote `image_url` fetches.
+ - all logged when a request carries them. On the media path: remote `image_url` fetches.
diff --git a/utils/dasllama-server/_server_rig.das b/utils/dasllama-server/_server_rig.das
index 06051fb42b..8f4c94f1b4 100644
--- a/utils/dasllama-server/_server_rig.das
+++ b/utils/dasllama-server/_server_rig.das
@@ -6,8 +6,7 @@ module _server_rig shared
 require dastest/testing_boost public
 require daslib/fio
 require daslib/clargs   // get_host_binary: the daslang a child runs under
-require daslib/base64   // file_base64
-require openai/openai_vision   // image_file_data_uri: the one data: URI builder
+require openai/openai_vision   // file_base64, image_file_data_uri: the one file reader and data: URI builder
 require math
 require daslib/jobque_boost   // hold_engine: the holding request and its control on threads of their own
 require strings
@@ -39,18 +38,8 @@ def model_missing(t : T?; paths : array<string>) : bool {
     return false
 }
 
-//! A file's bytes as base64 (a byte read, not fread(path): a jpeg or a wav carries interior
-//! NULs, which a string read would truncate at); "" when unreadable.
-def file_base64(path : string) : string {
-    var inscope bytes : array<uint8>
-    fopen(path, "rb") $(f) {
-        if (f != null) {
-            bytes |> resize(int64(fstat(f).size))
-            fread(f, bytes)
-        }
-    }
-    return empty(bytes) ? "" : base64_encode(bytes)
-}
+//! A file's bytes as base64; "" when unreadable.
+def file_base64(path : string) : string => openai_vision::file_base64(path)
 
 //! An image file as the data: URI a browser's FileReader would produce; "" when unreadable.
 def image_data_uri(path : string) : string => image_file_data_uri(path)
diff --git a/utils/dasllama-server/cli.das b/utils/dasllama-server/cli.das
index a6888ddefb..58ab43708a 100644
--- a/utils/dasllama-server/cli.das
+++ b/utils/dasllama-server/cli.das
@@ -243,7 +243,7 @@ def private load_hearing(path : string; var why : string&) : Hearing {
         return <- h
     }
     if (audio_probe_proj_dim(path) == 0l) {
-        why = "{path} carries no audio tower this build serves (gemma4a)"
+        why = "{path} carries no audio tower this build serves (gemma4a, or a whisper-class tower: qwen2a, qwen2.5o, ultravox, voxtral)"
         return <- h
     }
     note("loading audio mmproj {path}")
@@ -266,7 +266,7 @@ def private queue_audio(m : Model; var chat : ChatSession; var h : Hearing; path
     }
     var rows : array<float>
     let n = encode_audio(h.emb, h.state, samples, rows)
-    add_user_audio_rows(m, chat, rows, n)
+    add_user_audio_rows(m, chat, rows, n, audio_span_bare(h.emb))
     note("audio {double(length(samples)) / 16000.0lf} s -> {n} soft tokens")
     return true
 }
@@ -566,12 +566,15 @@ class CliEngine : ReplEngine {
     }
 }
 
-//! The audio tower a chat arms: the flag, else the served mmproj when it carries an audio encoder
-//! (the E-series file serves both towers).
+//! The audio tower a chat arms: the flag, else the served config's audio mmproj, else its image mmproj when that
+//! file carries an audio encoder too (the E-series and Omni files serve both towers).
 def private chat_audio_mmproj(plan : CliPlan; cfg : CliConfig) : string {
     if (!empty(plan.chat.audio_mmproj)) {
         return plan.chat.audio_mmproj
     }
+    if (!empty(cfg.audio_mmproj)) {
+        return cfg.audio_mmproj
+    }
     return (!empty(cfg.image_mmproj) && stat(cfg.image_mmproj).is_valid && audio_probe_proj_dim(cfg.image_mmproj) > 0l) ? cfg.image_mmproj : ""
 }
 
diff --git a/utils/dasllama-server/cli_args.das b/utils/dasllama-server/cli_args.das
index d590496bc5..d53cb2126c 100644
--- a/utils/dasllama-server/cli_args.das
+++ b/utils/dasllama-server/cli_args.das
@@ -579,6 +579,7 @@ struct CliConfig {
     path : string            // "" when no file was found
     model : string
     image_mmproj : string
+    audio_mmproj : string
     asr : string
     mmproj : string
     tts : string
@@ -634,6 +635,9 @@ def private apply_roster(root : JsonValue?; var cfg : CliConfig) {
     if (empty(cfg.image_mmproj)) {
         cfg.image_mmproj = pick?["image_mmproj"] ?? ""
     }
+    if (empty(cfg.audio_mmproj)) {
+        cfg.audio_mmproj = pick?["audio_mmproj"] ?? ""
+    }
     if (empty(cfg.quant)) {
         cfg.quant = pick?["quant"] ?? ""
     }
@@ -670,6 +674,7 @@ def parse_cli_config(body : string; var cfg : CliConfig) : bool {
     }
     cfg.model = root?["model"] ?? ""
     cfg.image_mmproj = root?["image_mmproj"] ?? ""
+    cfg.audio_mmproj = root?["audio_mmproj"] ?? ""
     // a speech key is one path, or an [[asr]] / [[tts]] roster whose first table is the default model
     let asr0 = first_table(root, "asr")
     cfg.asr = asr0 != null ? (asr0?["path"] ?? "") : (root?["asr"] ?? "")
diff --git a/utils/dasllama-server/control.html b/utils/dasllama-server/control.html
index ae4e9f2646..32fb443912 100644
--- a/utils/dasllama-server/control.html
+++ b/utils/dasllama-server/control.html
@@ -2135,6 +2135,7 @@
     { k: "tts_lane", t: "sel", o: ["q8", "f32"] },
     { k: "tts_voices_dir", t: "path", wide: true },
     { k: "image_mmproj", t: "path", wide: true },
+    { k: "audio_mmproj", t: "path", wide: true },
     { k: "asr_workers", t: "int" },
     { k: "lcpp_bin", t: "path", wide: true },
     { k: "models_dir", t: "path", wide: true },
@@ -2318,7 +2319,7 @@
 // so the TOML stays name+path per model unless something is genuinely overridden.
 const QUANT_OPTS = ["", "q8", "fp32", "q4", "q8_0", "q4_0", "q4_k", "q5_k", "q6_k", "mxfp4", "f16", "bf16"];
 const KV_OPTS = ["", "f16", "f32", "q8_0", "tq4"];
-let roster = [];         // {name, path, backend, ctx, quant, kv_dtype, streams, chunk, page_rows, prefix, mtp, rope_scaling, rope_scale, yarn_orig_ctx, image_mmproj, def, adv}
+let roster = [];         // {name, path, backend, ctx, quant, kv_dtype, streams, chunk, page_rows, prefix, mtp, rope_scaling, rope_scale, yarn_orig_ctx, image_mmproj, audio_mmproj, def, adv}
 const ROPE_OPTS = ["", "yarn", "linear", "none"];
 let gpuStatus = null;    // /config status.gpu — decline reason for the effective badge hover
 
@@ -2343,6 +2344,7 @@
         rope_scale: e.rope_scale > 0 ? String(e.rope_scale) : "",
         yarn_orig_ctx: e.yarn_orig_ctx > 0 ? String(e.yarn_orig_ctx) : "",
         image_mmproj: e.image_mmproj || "",
+        audio_mmproj: e.audio_mmproj || "",
         def: !!e.default,
         adv: false,
     }));
@@ -2449,7 +2451,8 @@
                 wrap("rope_scaling", rosterSelect(i, "rope_scaling", r.rope_scaling, ROPE_OPTS)),
                 wrap("rope_scale", rosterInput(i, "rope_scale", r.rope_scale, "number")),
                 wrap("yarn_orig_ctx", rosterInput(i, "yarn_orig_ctx", r.yarn_orig_ctx, "number")),
-                wrap("image_mmproj", rosterInput(i, "image_mmproj", r.image_mmproj, "text")));
+                wrap("image_mmproj", rosterInput(i, "image_mmproj", r.image_mmproj, "text")),
+                wrap("audio_mmproj", rosterInput(i, "audio_mmproj", r.audio_mmproj, "text")));
             for (const inp of grid.querySelectorAll("input")) inp.placeholder = "inherit";
             td.append(grid);
             at.append(td);
@@ -2498,7 +2501,7 @@
 $("b-addmodel").addEventListener("click", () => {
     roster.push({ name: "", path: "", backend: "auto", ctx: "", quant: "", kv_dtype: "",
                   streams: "", chunk: "", page_rows: "", prefix: "", mtp: "",
-                  rope_scaling: "", rope_scale: "", yarn_orig_ctx: "", image_mmproj: "",
+                  rope_scaling: "", rope_scale: "", yarn_orig_ctx: "", image_mmproj: "", audio_mmproj: "",
                   def: roster.length === 0, adv: false });
     renderRoster();
 });
@@ -2520,6 +2523,7 @@
         if (r.rope_scale !== "" && Number(r.rope_scale) > 0) e.rope_scale = Number(r.rope_scale);
         if (r.yarn_orig_ctx !== "" && Math.trunc(+r.yarn_orig_ctx) > 0) e.yarn_orig_ctx = Math.trunc(+r.yarn_orig_ctx);
         if (r.image_mmproj) e.image_mmproj = r.image_mmproj;
+        if (r.audio_mmproj) e.audio_mmproj = r.audio_mmproj;
         if (r.def) e.default = true;
         return e;
     });
diff --git a/utils/dasllama-server/main.das b/utils/dasllama-server/main.das
index ce8ff4f0e4..9f54c8fbe4 100644
--- a/utils/dasllama-server/main.das
+++ b/utils/dasllama-server/main.das
@@ -106,9 +106,13 @@ struct ServerArgs {
     tts_voices_dir : string
 
     @clarg_name = "image-mmproj"
-    @clarg_doc = "Vision mmproj (gemma4uv, gemma4v, or gemma3v, sniffed) for the default model — enables image_url parts on /v1/chat/completions"
+    @clarg_doc = "Vision mmproj (gemma4uv, gemma4v, or gemma3v, sniffed) for the default model — enables image_url parts on /v1/chat/completions; a file that carries an audio tower too (the gemma-4 E-series) arms input_audio parts with it"
     image_mmproj : string
 
+    @clarg_name = "audio-mmproj"
+    @clarg_doc = "Audio mmproj (a whisper-class tower: Qwen2-Audio, Qwen2.5-Omni, Ultravox, Voxtral; or gemma4a) for the default model — enables input_audio parts on /v1/chat/completions. An --image-mmproj that carries an audio tower arms it with no second flag"
+    audio_mmproj : string
+
     @clarg_doc = "Long-lived asynchronous ASR worker threads (default 1; 2 permits two parallel transcriptions; with several ASR models, the first one's)"
     asr_workers : int
 
@@ -194,6 +198,7 @@ struct ModelEntry {
     rope_scale : float = 0.0     // 0 inherits
     yarn_orig_ctx : int = 0      // 0 inherits
     image_mmproj : string   // vision mmproj (gemma4uv); empty = this model takes text only
+    audio_mmproj : string   // audio mmproj; empty = the image mmproj's audio tower, where it carries one
     is_default : bool = false
 }
 
@@ -269,7 +274,7 @@ var private g_cfg_sources : table<string; string>
 var private g_cfg_authoritative = false
 
 let CONFIG_KEYS = fixed_array("model", "port", "quant", "kv_dtype", "metal", "gpu", "gpu_layers",
-    "gpu_stream", "gpu_dn", "gpu_attn", "gpu_dense", "gpu_vram_mb", "asr", "mmproj", "image_mmproj", "asr_workers", "tts", "tts_lane", "tts_voices_dir",
+    "gpu_stream", "gpu_dn", "gpu_attn", "gpu_dense", "gpu_vram_mb", "asr", "mmproj", "image_mmproj", "audio_mmproj", "asr_workers", "tts", "tts_lane", "tts_voices_dir",
     "ctx", "max_tokens", "streams", "threads", "team_dispatch", "affinity", "chunk", "chunk_idle", "page_rows",
     "prefix", "flat", "mtp", "rope_scaling", "rope_scale", "yarn_orig_ctx", "lcpp_bin", "models_dir", "models")
 
@@ -379,11 +384,14 @@ def speech_roster_ids(tts : bool) : array<string> {
     return <- [for (m in tts ? g_tts_models : g_asr_models); empty(m.id) ? m.path : m.id]
 }
 
-//! whether any configured TTS model has its whole file set: such a boot serves the speech route with no LLM
-def private any_tts_present : bool {
+//! whether any configured speech model has its whole file set: such a boot serves its speech route with no LLM
+def private any_speech_present : bool {
     for (m in g_tts_models) {
         return true if (tts_files_present(m.path))
     }
+    for (a in g_asr_models) {
+        return true if (stat(a.path).is_valid && (empty(a.mmproj) || stat(a.mmproj).is_valid))
+    }
     return false
 }
 
@@ -489,6 +497,9 @@ def private mark_cli_sources(cfg : ServerArgs) {   // nolint:STYLE037,STYLE038 
     if (!empty(cfg.image_mmproj)) {
         g_cfg_sources["image_mmproj"] = "cli"
     }
+    if (!empty(cfg.audio_mmproj)) {
+        g_cfg_sources["audio_mmproj"] = "cli"
+    }
     if (cfg.asr_workers > 0) {
         g_cfg_sources["asr_workers"] = "cli"
     }
@@ -545,6 +556,25 @@ def private mark_cli_sources(cfg : ServerArgs) {   // nolint:STYLE037,STYLE038 
     }
 }
 
+//! the flat keys that size a model's sessions and scheduler
+def private apply_session_keys(root : JsonValue?; var cfg : ServerArgs; auth : bool) {
+    cfg_from_toml(root, "ctx", cfg.ctx, auth)
+    cfg_from_toml(root, "max_tokens", cfg.max_tokens, auth)
+    cfg_from_toml(root, "streams", cfg.streams, auth)
+    cfg_from_toml(root, "threads", cfg.threads, auth)
+    cfg_from_toml(root, "team_dispatch", cfg.team_dispatch, auth)
+    cfg_from_toml(root, "affinity", cfg.affinity, auth)
+    cfg_from_toml(root, "chunk", cfg.chunk, auth)
+    cfg_from_toml(root, "chunk_idle", cfg.chunk_idle, auth)
+    cfg_from_toml(root, "page_rows", cfg.page_rows, auth)
+    cfg_from_toml(root, "prefix", cfg.prefix, auth)
+    cfg_from_toml(root, "flat", cfg.flat, auth)
+    cfg_from_toml(root, "mtp", cfg.mtp, auth)
+    cfg_from_toml(root, "rope_scaling", cfg.rope_scaling, auth)
+    cfg_from_toml(root, "rope_scale", cfg.rope_scale, auth)
+    cfg_from_toml(root, "yarn_orig_ctx", cfg.yarn_orig_ctx, auth)
+}
+
 // fill fields from the TOML config. Default precedence: defaults < config file < explicit CLI
 // flags. A config carrying `authoritative = true` (what the control page writes) flips the top:
 // its keys override CLI flags too (defaults < CLI < authoritative TOML).
@@ -586,22 +616,9 @@ def apply_config(var cfg : ServerArgs) : bool {
     cfg_from_toml(root, "tts_lane", cfg.tts_lane, auth)
     cfg_from_toml(root, "tts_voices_dir", cfg.tts_voices_dir, auth)
     cfg_from_toml(root, "image_mmproj", cfg.image_mmproj, auth)
+    cfg_from_toml(root, "audio_mmproj", cfg.audio_mmproj, auth)
     cfg_from_toml(root, "asr_workers", cfg.asr_workers, auth)
-    cfg_from_toml(root, "ctx", cfg.ctx, auth)
-    cfg_from_toml(root, "max_tokens", cfg.max_tokens, auth)
-    cfg_from_toml(root, "streams", cfg.streams, auth)
-    cfg_from_toml(root, "threads", cfg.threads, auth)
-    cfg_from_toml(root, "team_dispatch", cfg.team_dispatch, auth)
-    cfg_from_toml(root, "affinity", cfg.affinity, auth)
-    cfg_from_toml(root, "chunk", cfg.chunk, auth)
-    cfg_from_toml(root, "chunk_idle", cfg.chunk_idle, auth)
-    cfg_from_toml(root, "page_rows", cfg.page_rows, auth)
-    cfg_from_toml(root, "prefix", cfg.prefix, auth)
-    cfg_from_toml(root, "flat", cfg.flat, auth)
-    cfg_from_toml(root, "mtp", cfg.mtp, auth)
-    cfg_from_toml(root, "rope_scaling", cfg.rope_scaling, auth)
-    cfg_from_toml(root, "rope_scale", cfg.rope_scale, auth)
-    cfg_from_toml(root, "yarn_orig_ctx", cfg.yarn_orig_ctx, auth)
+    apply_session_keys(root, cfg, auth)
     cfg_from_toml(root, "lcpp_bin", cfg.lcpp_bin, auth)
     cfg_from_toml(root, "models_dir", cfg.models_dir, auth)
     if (toml_has(root, "models")) {
@@ -689,6 +706,7 @@ def private apply_models_roster(root : JsonValue?) {
             rope_scaling = e?["rope_scaling"] ?? "", rope_scale = float(e?["rope_scale"] ?? 0.0lf),
             yarn_orig_ctx = int(e?["yarn_orig_ctx"] ?? 0l),
             image_mmproj = e?["image_mmproj"] ?? "",
+            audio_mmproj = e?["audio_mmproj"] ?? "",
             is_default = e?["default"] ?? false)
         if (ent.backend != "auto" && ent.backend != "cpu" && ent.backend != "gpu") {
             to_log(LOG_WARNING, "dasllama-server: [[models]] '{base_name(ent.path)}' backend '{ent.backend}' is not auto | cpu | gpu — using auto\n")
@@ -762,6 +780,7 @@ def private roster_entry_json(ent : ModelEntry) : JsonValue? {
         "chunk_idle" => JV(int64(ent.chunk_idle)),
         "page_rows" => JV(int64(ent.page_rows)), "prefix" => JV(int64(ent.prefix)),
         "image_mmproj" => JV(ent.image_mmproj),
+        "audio_mmproj" => JV(ent.audio_mmproj),
         "default" => JV(ent.is_default)
     }
     if (ent.mtp >= 0) {
@@ -819,6 +838,7 @@ def private build_config_surface(cfg : ServerArgs; save_path : string) : string
         tts_lane = pick_tts_lane(cfg.tts_lane),   // the lane configure_tts kept, not the spelling asked for
         tts_voices_dir = cfg.tts_voices_dir,
         image_mmproj = cfg.image_mmproj,
+        audio_mmproj = cfg.audio_mmproj,
         asr_workers = cfg.asr_workers > 0 ? cfg.asr_workers : 1,
         ctx = cfg.ctx,
         max_tokens = cfg.max_tokens > 0 ? cfg.max_tokens : 16384,
@@ -904,11 +924,10 @@ def parse_args() {
         request_exit()
         return
     }
-    // a [[models]] roster needs no flat model key; a --tts start with its file set complete is a
-    // SERVING server (the speech route), so it never enters setup mode - an incomplete set is one
-    // configure_tts drops, which leaves this boot nothing to serve
+    // a [[models]] roster needs no flat model key; a --tts or --asr start with its file set complete
+    // is a SERVING server (the speech routes), so it never enters setup mode
     speech_roster_from_flags(g_cfg)
-    if (empty(g_cfg.model) && empty(g_models) && !any_tts_present()) {
+    if (empty(g_cfg.model) && empty(g_models) && !any_speech_present()) {
         g_setup_mode = true
         print("no model configured - starting in setup mode (open the control page to download one from the catalog)\n")
     }
@@ -1079,21 +1098,29 @@ def init() {   // nolint:STYLE037,STYLE038 — boot sequence: the knobs are orde
             to_log(LOG_ERROR, "dasllama-server: dropping the vision arm of '{empty(e.name) ? base_name(e.path) : e.name}' - mmproj not found: {e.image_mmproj}\n")
             e.image_mmproj = ""
         }
+        if (!empty(e.audio_mmproj) && !stat(e.audio_mmproj).is_valid) {
+            to_log(LOG_ERROR, "dasllama-server: dropping the audio arm of '{empty(e.name) ? base_name(e.path) : e.name}' - mmproj not found: {e.audio_mmproj}\n")
+            e.audio_mmproj = ""
+        }
         roster |> push(e)
     }
     delete g_models
     g_models <- roster
-    if (empty(g_models) && !g_setup_mode && !any_tts_present()) {
+    if (empty(g_models) && !g_setup_mode && !any_speech_present()) {
         // not an exit: a crash-looping boot under the watchdog never gets a page to fix the config from
         g_setup_mode = true
-        to_log(LOG_ERROR, "dasllama-server: no loadable model - no configured path survived its file check (roster entries, and the --tts file set); starting in setup mode\n")
+        to_log(LOG_ERROR, "dasllama-server: no loadable model - no configured path survived its file check (roster entries, and the --tts and --asr file sets); starting in setup mode\n")
     } elif (empty(g_models) && !g_setup_mode) {
-        to_log(LOG_WARNING, "dasllama-server: no loadable LLM model - serving the speech route only (the TTS model still loads)\n")
+        to_log(LOG_WARNING, "dasllama-server: no loadable LLM model - serving the speech routes only (the TTS and ASR models still load)\n")
     }
     if (!empty(g_cfg.image_mmproj) && !stat(g_cfg.image_mmproj).is_valid) {
         to_log(LOG_ERROR, "dasllama-server: dropping --image-mmproj - file not found: {g_cfg.image_mmproj}\n")
         g_cfg.image_mmproj = ""
     }
+    if (!empty(g_cfg.audio_mmproj) && !stat(g_cfg.audio_mmproj).is_valid) {
+        to_log(LOG_ERROR, "dasllama-server: dropping --audio-mmproj - file not found: {g_cfg.audio_mmproj}\n")
+        g_cfg.audio_mmproj = ""
+    }
     if (!g_setup_mode) {
         var def_idx = 0
         for (i in range(length(g_models))) {
@@ -1183,13 +1210,16 @@ def init() {   // nolint:STYLE037,STYLE038 — boot sequence: the knobs are orde
         for (i in range(length(g_models))) {
             let path = (!empty(g_models[i].image_mmproj) ? g_models[i].image_mmproj
                                                          : (i == def_idx ? g_cfg.image_mmproj : ""))
+            let audio = (!empty(g_models[i].audio_mmproj) ? g_models[i].audio_mmproj
+                                                          : (i == def_idx ? g_cfg.audio_mmproj : ""))
             if (!empty(path)) {
                 set_model_vision(g_models[i].name, path)
-                // the E-series mmproj carries BOTH towers: the same file arms native audio, so
-                // one download gives text + vision + audio off the one serving slot
-                if (audio_probe_proj_dim(path) > 0l) {
-                    set_model_audio(g_models[i].name, path)
-                }
+            }
+            // an mmproj that carries both towers (the E-series, the Omni files) arms audio with the one flag
+            if (!empty(audio)) {
+                set_model_audio(g_models[i].name, audio)
+            } elif (!empty(path) && audio_probe_proj_dim(path) > 0l) {
+                set_model_audio(g_models[i].name, path)
             }
         }
 
@@ -1206,8 +1236,7 @@ def init() {   // nolint:STYLE037,STYLE038 — boot sequence: the knobs are orde
             add_asr_model(a.path, a.mmproj, max(a.workers, 1), a.id)
         }
     }
-    // outside the serving gate: a --tts start with no loadable LLM is a speech-only SERVER, and
-    // its route has to arm on that boot too
+    // a --tts start with no loadable LLM is a speech-only SERVER, and its route arms on that boot too
     configure_tts("")
     for (m in g_tts_models) {
         add_tts_model(m.path, m.lane, m.voices_dir, m.id)
diff --git a/utils/dasllama-server/openai_server.das b/utils/dasllama-server/openai_server.das
index 52838ee65c..ca18bcf28d 100644
--- a/utils/dasllama-server/openai_server.das
+++ b/utils/dasllama-server/openai_server.das
@@ -249,6 +249,7 @@ struct ModelSlot {
     vision : VisionEmbedder = VisionEmbedder()   // set_model_vision; kind == none = text only (encode runs on the media worker)
     vision_path : string                             // the worker loads its own embedder from this
     audio_armed : bool                           // set_model_audio; the media worker owns the encoder itself
+    audio_bare : bool                            // the audio encoder's rows splice with no span marker (ultravox)
     audio_path : string                              // the mmproj the worker loads the audio encoder from
     think_default : bool   // family default when the request sends no enable_thinking (THINKING.md's table)
 }
@@ -325,6 +326,7 @@ struct AsrSlot {
     mmproj : string
     workers : int
     ready : int                 //! workers that loaded and answered
+    decoder : string            //! where the workers decode, off a ready event: `metal` for a decoder loaded as the Metal flavor, else `cpu`
 }
 
 //! One served TTS model: one worker loads and owns it. The answer-side fields are the worker's own, off its ready event.
@@ -350,6 +352,7 @@ var private g_asr_alias = ""                //! the default ASR model's other na
 var private g_asr_jobs : array<Channel?>   //! a job channel a running ASR model, by its row; the thread that started the workers holds them
 var private g_tts_jobs : array<Channel?>   //! the same a TTS model, null for one that is not armed
 var g_asr_team_dispatch = false
+var g_speech_metal = MetalMode.off   //! the engine's Metal mode, handed to the ASR workers whose decoder is a Model session
 var g_tts_team_dispatch = false
 let TTS_VOICE_CLIP_EXTENSIONS : array<string> <- [".wav", ".flac", ".mp3", ".ogg"]   // what the decode rail reads
 var g_shutdown_requested = false
@@ -685,25 +688,28 @@ def private arm_slot_audio(mi : int; path : string) : string {
     }
     let proj_dim = audio_probe_proj_dim(path)
     if (proj_dim == 0l) {
-        return "{base_name(path)} carries no audio encoder dasLLAMA serves (gemma4a) - it cannot arm audio for {g_slots[mi].name}"
+        return "{base_name(path)} carries no audio encoder dasLLAMA serves (gemma4a, or a whisper-class tower: qwen2a, qwen2.5o, ultravox, voxtral) - it cannot arm audio for {g_slots[mi].name}"
     }
     if (proj_dim != g_slots[mi].model.config.dim) {
         return "{base_name(path)}'s audio encoder projects to {proj_dim} but {g_slots[mi].name} is {g_slots[mi].model.config.dim}-wide - mismatched pair"
     }
     var probe <- create_chat_renderer(g_slots[mi].model, "", 1l)
-    let no_markers = empty(probe.tmpl.audio_pre.parts) || !audio_vocab_ok(g_slots[mi].model, probe.tmpl)
+    // an ultravox span takes no marker: the stock decoder it pairs with declares none
+    let no_markers = !audio_probe_span_bare(path) && (empty(probe.tmpl.audio_pre.parts) || !audio_vocab_ok(g_slots[mi].model, probe.tmpl))
     delete probe
     if (no_markers) {
         return "{g_slots[mi].name}'s chat template or vocab carries no audio span markers - it has no audio arm"
     }
     g_slots[mi].audio_armed = true
+    g_slots[mi].audio_bare = audio_probe_span_bare(path)
     g_slots[mi].audio_path = path
     to_log(LOG_INFO, "dasllama-server: {g_slots[mi].name} audio arm: {base_name(path)} ({proj_dim}-wide)\n")
     return ""
 }
 
-//! Give slot `name` an audio arm: the mmproj at `path` must carry a gemma4a audio encoder (the
-//! E-series mmproj carries BOTH towers, so the same file arms vision and audio). The chat route
+//! Give slot `name` an audio arm: the mmproj at `path` must carry an audio encoder the engine serves - gemma4a,
+//! or a whisper-class tower (an E-series or Omni mmproj carries BOTH towers, so the same file arms vision
+//! and audio). The chat route
 //! then accepts `input_audio` content parts — the clip serves through THIS slot, no second
 //! decoder copy. Same call contract as ``set_model_vision``: once per slot, before
 //! ``init_server`` (the media worker snapshots the arms at init); a bad pair PANICS here.
@@ -831,6 +837,10 @@ def server_has_tts : bool {
     return tts_default() >= 0
 }
 
+//! True when a speech model serves with no LLM slot beside it: an armed TTS model or a configured ASR model.
+def server_has_speech : bool
+    => server_has_tts() || !empty(g_asr)
+
 //! Stop admitting new inference/ASR work and exit after all accepted work finishes. Also wired to
 //! ``POST /shutdown``.
 def request_stop() {
@@ -2667,15 +2677,17 @@ def private unwind_failed_runtime_load(id : string; prev_owner : int) {
 // Arm towers on a runtime-loaded slot from its mmproj; the returned note is "" or the
 // client-facing reason the slot serves text-only. Panics (a non-GGUF file, a bad projector)
 // are caught here — the model itself already serves.
-def private arm_runtime_towers(mi : int; mmproj : string) : string {
+def private arm_runtime_towers(mi : int; mmproj, audio_mmproj : string) : string {
     var note = ""
     var failure = ""
     let failed = catch_worker_panic(failure) {
-        let verr = arm_slot_vision(mi, mmproj)
-        if (!empty(verr)) {
-            note = verr
-        } elif (audio_probe_proj_dim(mmproj) > 0l) {
-            note = arm_slot_audio(mi, mmproj)   // the E-series file arms audio too
+        if (!empty(mmproj)) {
+            note = arm_slot_vision(mi, mmproj)
+        }
+        if (empty(note) && !empty(audio_mmproj)) {
+            note = arm_slot_audio(mi, audio_mmproj)
+        } elif (empty(note) && audio_probe_proj_dim(mmproj) > 0l) {
+            note = arm_slot_audio(mi, mmproj)   // a file with both towers arms audio too
         }
     }
     if (failed) {
@@ -2796,7 +2808,8 @@ def private handle_model_load(req : FrontReq; var resp : Reply) : http_status {
     }
     let mi_new = length(g_slots) - 1
     let mmproj = js?["image_mmproj"] ?? ""
-    let tower_note = empty(mmproj) ? "" : arm_runtime_towers(mi_new, mmproj)
+    let audio_mmproj = js?["audio_mmproj"] ?? ""
+    let tower_note = empty(mmproj) && empty(audio_mmproj) ? "" : arm_runtime_towers(mi_new, mmproj, audio_mmproj)
     if (js?["activate"] ?? true) {
         set_default_model(id)   // the default is the slot model-less (page) requests land on
         g_active = mi_new
@@ -2947,20 +2960,19 @@ def private resolve_stream_slot(srv : FrontLink; writer : WriterRef; js : JsonVa
 // would panic) and the 503 (queue full). Moves prompt/stop_ids/close_toks into the request.
 def private register_request(srv : FrontLink; writer : WriterRef;
                              var prompt, stop_ids, close_toks : array<int64>;
-                             var media : array<float>; media_at, n_media : int64;
+                             var spans : array<MediaSpan>;
                              params : SamplingParams; max_new : int64;
                              streaming, is_chat : bool; prefix : string;
                              tools_declared : bool = false; call_open : string = ""; call_close : string = "";
                              seed : int = 0; think : ThinkStream = ThinkStream();
                              tool_mode : ToolMode = ToolMode.none; reuse_id : int64 = 0l;
-                             media_is_audio : bool = false; media_grid : int2 = int2(0);
                              var nothink : NothinkStopGuard = NothinkStopGuard(); stable_at : int64 = 0l;
-                             include_usage : bool = false) {
+                             include_usage : bool = false; resumed : bool = false) {
     if (bench_hold_active()) {
         service_unavailable(srv, writer, ibench_hold_text())
         return
     }
-    let np = long_length(prompt) + n_media
+    let np = long_length(prompt)   // media positions included: a span's ids stand in the prompt
     if (np + 1l > cur_model().config.seq_len) {
         bad_request(srv, writer, "the rendered prompt is {np} tokens; the model context is {cur_model().config.seq_len} — shorten the conversation or raise --ctx")
         return
@@ -2968,25 +2980,23 @@ def private register_request(srv : FrontLink; writer : WriterRef;
     let rid = reuse_id != 0l ? reuse_id : next_id()   // a resumed image request keeps its park id, so one [req N] spans the request
     let cid = "{prefix}-{rid}"
     let created = created_ts()
-    var preq <- PendingReq(id = rid, params = params, max_new = max_new, seed = seed,
-                           media_at = media_at, n_media = n_media,
-                           media_non_causal = n_media > 0l && !media_is_audio,   // image span rows attend in full; audio rows stay causal
-                           media_grid = media_grid,   // qwen mrope grid; (0,0) on gemma families
-                           stable_at = stable_at)
+    var preq <- PendingReq(id = rid, params = params, max_new = max_new, seed = seed, stable_at = stable_at)
+    var encoded_rows = 0l
+    for (sp in spans) {
+        encoded_rows += empty(sp.rows) ? 0l : sp.n
+    }
     preq.prompt <- prompt
     preq.stop_ids <- stop_ids
     preq.nothink <- nothink
     preq.close_toks <- close_toks
-    preq.media_embd <- media
+    preq.spans <- spans
     if (!submit(cur_model(), cur_sched(), preq)) {
         delete preq
         to_log(LOG_WARNING, "dasllama-server: 503 queue full ({cur_sched().max_queue}) — rejected {prefix} request ({np} tok)\n")
         service_unavailable(srv, writer, "the server is at capacity ({cur_sched().max_queue} requests queued) — retry shortly")
         return
     }
-    g_media_rows += n_media   // after submit: a 503-rejected request counts nothing (an image
-                              // request reaches here once — it parks at the encode boundary
-                              // BEFORE this function and re-enters only as the resume)
+    g_media_rows += encoded_rows   // after submit: a 503-rejected request counts nothing; a span the prefix cache serves brought no rows
     g_slots[g_cur].last_used = ref_time_ticks()
     set_writer_keepalive_timeout(srv, writer, LLM_WRITER_KEEPALIVE_MS)
     to_log(LOG_INFO, "[req {rid}] {prefix}: prompt={np} tok, stream={streaming}, max_new={max_new}\n")
@@ -2997,7 +3007,7 @@ def private register_request(srv : FrontLink; writer : WriterRef;
                            call_open = call_open, call_close = call_close,
                            tool_mode = tool_mode, think = think)
     g_wires[rid] <- wire
-    if (streaming && is_chat) {
+    if (streaming && is_chat && !resumed) {
         send_chat_chunk(srv, writer, cid, created, "assistant", "", "")   // opening role delta
     }
 }
@@ -3008,11 +3018,11 @@ def private register_request(srv : FrontLink; writer : WriterRef;
 // Render a user-led suffix of the transcript. System messages are always retained (they were
 // folded into `system`); `start` applies only to conversational messages in the original array.
 def private render_chat_suffix(msgs_v : JsonValue?; system : string; tools : array<string>;   // nolint:STYLE037,STYLE038 — one arm per message role, each accumulating into the same renderer state
-                               max_new : int64; start : int; think_set, think_val, has_media, media_is_audio : bool;
+                               max_new : int64; start : int; think_set, think_val : bool; refs : array<MediaRef>;
                                var prompt, stop_ids, close : array<int64>&;
                                var nothink_out : NothinkStopGuard&;
                                var call_open, call_close : string&; var think_out : ThinkStream&;
-                               var tool_mode_out : ToolMode&; var media_at, stable_at : int64&) : string {
+                               var tool_mode_out : ToolMode&; var stable_at : int64&) : string {
     var chat <- create_chat_renderer(cur_model(), system, max_new)
     defer() { delete chat }
     if (think_set) {   // absent from the request => the family's own default (gemma-4 E: off)
@@ -3070,6 +3080,10 @@ def private render_chat_suffix(msgs_v : JsonValue?; system : string; tools : arr
         }
         if (role == "user") {
             add_user(chat, content)
+            for (r in refs) {   // the message's media, inline where its parts sit among the text
+                continue if (r.msg != i)
+                add_user_span(cur_model(), chat, r.key, r.n_rows, r.text_before, !r.is_audio, r.is_audio && g_slots[g_cur].audio_bare)
+            }
             pending = true
         } elif (role == "assistant") {
             var calls : array<string>
@@ -3121,28 +3135,10 @@ def private render_chat_suffix(msgs_v : JsonValue?; system : string; tools : arr
         delete rendered
         return "the last message must be a user or tool message"
     }
-    media_at = 0l
-    stable_at = 0l
-    if (has_media) {
-        // the media turn renders as TWO token spans; the soft-token rows prefill between them, so
-        // the scheduler gets one flat prompt plus the index the rows splice at
-        var head : array<int64>
-        var tail : array<int64>
-        if (media_is_audio) {
-            render_turn_audio(cur_model(), chat, head, tail)
-        } else {
-            render_turn_image(cur_model(), chat, head, tail)
-        }
-        media_at = long_length(rendered) + long_length(head)
-        rendered |> push_from(head, tail)
-        delete head
-        delete tail
-    } else {
-        var turn <- render_turn_marked(cur_model(), chat)
-        stable_at = long_length(rendered) + turn.opening   //! every earlier turn, and the last turn's own opening
-        rendered |> push_from(turn.toks)
-        delete turn
-    }
+    var turn <- render_turn_marked(cur_model(), chat)
+    stable_at = long_length(rendered) + turn.opening   //! every earlier turn, and the last turn's own opening
+    rendered |> push_from(turn.toks)
+    delete turn
     // out-params: the sole caller hands them in empty and deletes them before every re-render
     prompt <- rendered      // nolint:PERF030 — empty on entry
     stop_ids <- turn_stop_ids(chat)   // nolint:PERF030 — empty on entry; the thinking-off extras ride the guard
@@ -3197,9 +3193,9 @@ def private handle_chat(srv : FrontLink; req : FrontReq; writer : WriterRef) {
     if (parked == MediaPark.answered) {
         return   // an error already went out; the defer frees js
     }
-    var no_media : array<float>
-    defer() { delete no_media }
-    handle_chat_tail(srv, writer, js, g_cur, no_media, 0l)
+    var no_refs : array<MediaRef>
+    defer() { delete no_refs }
+    handle_chat_tail(srv, writer, js, g_cur, no_refs)
 }
 
 enum private MediaPark {
@@ -3208,90 +3204,198 @@ enum private MediaPark {
     parked     // the request is parked with the media worker, which now owns js
 }
 
-// The chat route's media boundary: ONE image or ONE audio clip, on the FINAL message (a user
-// message carrying it). Any other placement warns and drops — an earlier turn has no render seam
-// (replays go through render_assistant, which has no splice), and a trailing tool turn must render
-// as tools.
+//! One media part of a request: the message and text offset it sits at, the content key its positions carry, and its
+//! soft-token rows once encoded. `n_rows` is known ahead of the rows for media this slot has encoded before.
+struct private MediaRef {
+    key : uint64
+    is_audio : bool
+    msg : int
+    text_before : int
+    payload : string            // the part's base64 / data URI, inside the parked request's JSON
+    n_rows : int64
+    grid : int2
+    rows : array<float>
+    want_rows : bool            // known, but the prefix cache does not hold its span under this prompt: encode it
+}
+
+//! what a slot remembers of media it encoded: the span's shape, which a transcript needs to lay the span out
+struct private MediaSeen {
+    n_rows : int64
+    grid : int2
+}
+
+let MEDIA_SPANS_LIMIT = 16     // media parts one request may carry, every message's
+let MEDIA_SEEN_LIMIT = 4096    // remembered span shapes; past it the table starts over
+
+var private g_media_seen : table<uint64; MediaSeen>
+
+//! the media parts of every user message, in transcript order, each at its text offset in its message
+def private collect_media_refs(msgs_v : JsonValue?; var refs : array<MediaRef>) {
+    let salt = hash(g_slots[g_cur].name)
+    for (i in range(length(msgs_v.value as _array))) {
+        let mv = (msgs_v.value as _array)[i]
+        let cv = mv?["content"]
+        continue if (cv == null || !(cv.value is _array))
+        let is_user = (mv?["role"] ?? "") == "user"
+        var at = 0
+        for (pv in (cv.value as _array)) {
+            let ptype = pv?["type"] ?? ""
+            var payload = ""
+            if (ptype == "text") {
+                at += length(pv?["text"] ?? "")
+            } elif (ptype == "image_url") {
+                let uv = pv?["image_url"]
+                payload = uv != null && uv.value is _string ? (uv ?? "") : (uv?["url"] ?? "")
+            } elif (ptype == "input_image") {
+                payload = pv?["image_url"] ?? ""
+            } elif (ptype == "input_audio") {
+                payload = pv?["input_audio"]?["data"] ?? ""
+            }
+            continue if (ptype == "text" || empty(payload) && ptype != "image_url" && ptype != "input_image" && ptype != "input_audio")
+            if (!is_user) {
+                to_log(LOG_WARNING, "/v1/chat/completions: dropping a media part on message {i} - media rides user messages\n")
+                continue
+            }
+            let is_audio = ptype == "input_audio"
+            refs |> emplace(MediaRef(key = hash_combine64(hash_combine64(hash(payload), salt), is_audio ? 1ul : 2ul),
+                                     is_audio = is_audio, msg = i, text_before = at, payload = payload))
+        }
+    }
+}
+
+//! Send the worker a job for every ref that needs rows - all of them under `force`, else the ones this slot never
+//! encoded; a job's id maps back to its ref. False with `why` when a part does not decode.
+def private encode_media_refs(rid : int64; var wire : MediaWire; force : bool; var why : string&) : bool {
+    for (r, ri in wire.refs, count()) {
+        continue if (!empty(r.rows) || (!force && !r.want_rows && r.n_rows > 0l))
+        r.want_rows = false
+        var file_bytes : array<uint8>
+        let decoded = (r.is_audio ? decode_base64_bytes(r.payload, file_bytes, why)
+            : decode_data_uri_bytes(r.payload, file_bytes, why))
+        if (!decoded) {
+            delete file_bytes
+            return false
+        }
+        let jid = next_id()
+        var vjob = MediaJob(id = jid, name = g_slots[wire.slot].name, file_bytes <- file_bytes, tag = "req{rid}",
+                            is_audio = r.is_audio,
+                            max_audio_frames = r.is_audio ? audio_decode_frame_cap(g_slots[wire.slot].model.config.seq_len) : 0)
+        g_media_jobs |> push_clone(vjob)
+        delete vjob
+        g_media_job_ref[jid] = MediaJobRef(wire = rid, at = ri)
+        g_media_pending++
+        wire.jobs_left++
+    }
+    return true
+}
+
+// The chat route's media boundary: every image and audio part of every user message stays in the transcript, at its
+// place among the message's text. A part this slot has encoded before goes to the scheduler with no rows - the
+// prefix cache holds its span on a continued chat - and only a new part parks with the media worker.
 def private park_media_request(srv : FrontLink; writer : WriterRef;
                                var js : JsonValue?; msgs_v : JsonValue?) : MediaPark {
-    var images : array<string>
-    defer() { delete images }
-    var audios : array<string>
-    defer() { delete audios }
-    let n_msgs = length(msgs_v.value as _array)
-    for (i in range(n_msgs)) {
-        var img_here : array<string>
-        var aud_here : array<string>
-        message_parts((msgs_v.value as _array)[i], "/v1/chat/completions", img_here, aud_here)
-        let is_final_user = i == n_msgs - 1 && ((msgs_v.value as _array)[i]?["role"] ?? "") == "user"
-        if ((!empty(img_here) || !empty(aud_here)) && !is_final_user) {
-            to_log(LOG_WARNING, "/v1/chat/completions: dropping {length(img_here) + length(aud_here)} media part(s) on message {i} — media is read from the FINAL user message only\n")
-        } else {
-            images |> push_from(img_here)
-            audios |> push_from(aud_here)
-        }
-        delete img_here
-        delete aud_here
-    }
-    if (empty(images) && empty(audios)) {
+    var refs : array<MediaRef>
+    collect_media_refs(msgs_v, refs)
+    if (empty(refs)) {
+        delete refs
         return MediaPark.none
     }
-    if (!empty(images) && !empty(audios)) {
-        bad_request(srv, writer, "one media clip per request — this message carries an image AND audio")
-        return MediaPark.answered
-    }
-    let is_audio = !empty(audios)
-    if (is_audio && !g_slots[g_cur].audio_armed) {
-        bad_request(srv, writer, "model '{cur_name()}' has no audio arm — start the server with its (audio-carrying) mmproj for it to accept input_audio parts")
+    var refusal = ""
+    var n_new = 0
+    for (r in refs) {
+        if (r.is_audio && !g_slots[g_cur].audio_armed) {
+            refusal = "model '{cur_name()}' has no audio arm — start the server with --audio-mmproj (or an --image-mmproj that carries an audio tower) for it to accept input_audio parts"
+        } elif (!r.is_audio && g_slots[g_cur].vision.kind == VisionKind.none) {
+            refusal = "model '{cur_name()}' has no vision arm — start the server with an image mmproj for it to accept image_url parts"
+        }
+        let seen = g_media_seen?[r.key] ?? MediaSeen()
+        r.n_rows = seen.n_rows
+        r.grid = seen.grid
+        n_new += seen.n_rows == 0l ? 1 : 0
+    }
+    let has_new = n_new > 0
+    if (empty(refusal) && length(refs) > MEDIA_SPANS_LIMIT) {
+        refusal = "this request carries {length(refs)} media parts; the limit is {MEDIA_SPANS_LIMIT}"
+    }
+    if (!empty(refusal)) {
+        delete refs
+        bad_request(srv, writer, refusal)
         return MediaPark.answered
     }
-    if (!is_audio && g_slots[g_cur].vision.kind == VisionKind.none) {
-        bad_request(srv, writer, "model '{cur_name()}' has no vision arm — start the server with an image mmproj for it to accept image_url parts")
-        return MediaPark.answered
-    }
-    if (length(images) > 1 || length(audios) > 1) {
-        bad_request(srv, writer, "one media clip per request — this message carries {length(images) + length(audios)}")
-        return MediaPark.answered
-    }
-    if (!g_media_armed || g_media_ready < 1) {
+    if (has_new && (!g_media_armed || g_media_ready < 1)) {
+        delete refs
         service_unavailable(srv, writer, "the media worker is not ready")
         return MediaPark.answered
     }
-    if (g_media_pending >= MEDIA_QUEUE_LIMIT) {
+    if (g_media_pending + n_new > MEDIA_QUEUE_LIMIT) {
+        delete refs
         service_unavailable(srv, writer, "the media queue is at capacity ({MEDIA_QUEUE_LIMIT}) — retry shortly")
         return MediaPark.answered
     }
-    var file_bytes : array<uint8>
+    // park at the encode boundary: the worker decodes + encodes off-thread, and drain_media_events resumes at
+    // handle_chat_tail with the rows; a request of known media resumes at once, its wire kept for a lost span
+    let rid = next_id()
+    set_writer_keepalive_timeout(srv, writer, LLM_WRITER_KEEPALIVE_MS)
+    g_media_wires[rid] <- MediaWire(writer = writer, js = js, slot = g_cur, refs <- refs)
+    var wire = unsafe(g_media_wires?[rid])
     var why = ""
-    let decoded = (is_audio ? decode_base64_bytes(audios[0], file_bytes, why)
-        : decode_data_uri_bytes(images[0], file_bytes, why))
-    if (!decoded) {
-        delete file_bytes
+    if (!encode_media_refs(rid, *wire, false, why)) {
+        drop_media_wire(rid, false)
         bad_request(srv, writer, why)
         return MediaPark.answered
     }
-    // park at the encode boundary: the worker decodes + encodes off-thread, and
-    // drain_media_events resumes at handle_chat_tail with the rows
-    let rid = next_id()
-    set_writer_keepalive_timeout(srv, writer, LLM_WRITER_KEEPALIVE_MS)
-    g_media_wires[rid] <- MediaWire(writer = writer, js = js, slot = g_cur, is_audio = is_audio)
-    let max_audio_frames = is_audio ? audio_decode_frame_cap(g_slots[g_cur].model.config.seq_len) : 0
-    var vjob = MediaJob(id = rid, name = g_slots[g_cur].name, file_bytes <- file_bytes, tag = "req{rid}",
-                        is_audio = is_audio, max_audio_frames = max_audio_frames)
-    g_media_jobs |> push_clone(vjob)
-    delete vjob
-    g_media_pending++
-    to_log(LOG_INFO, "[req {rid}] {is_audio ? "audio" : "image"} parked for the media worker ({g_media_pending} queued or in flight)\n")
+    if (wire.jobs_left > 0) {
+        to_log(LOG_INFO, "[req {rid}] {wire.jobs_left} media part(s) parked for the media worker, {length(wire.refs) - wire.jobs_left} known ({g_media_pending} queued or in flight)\n")
+    } else {
+        to_log(LOG_INFO, "[req {rid}] {length(wire.refs)} media part(s), every one known\n")
+        resume_media_request(srv, rid)
+    }
     return MediaPark.parked
 }
 
+//! free a parked request's wire; `keep_js` where the caller's own defer frees the request JSON
+def private drop_media_wire(rid : int64; free_js : bool) {
+    return if (!key_exists(g_media_wires, rid))
+    if (free_js) {
+        unsafe {
+            delete g_media_wires[rid].js
+        }
+    }
+    g_media_wires[rid].js = null
+    delete g_media_wires[rid]
+    g_media_wires |> erase(rid)
+}
+
+//! every job of a parked request is in: render and submit it. The wire stays until the stream's first event, since a
+//! span submitted with no rows may turn out lost.
+def private resume_media_request(srv : FrontLink; rid : int64) {
+    var wire = unsafe(g_media_wires?[rid])
+    return if (wire == null)
+    wire.submitted = true
+    handle_chat_tail(srv, wire.writer, wire.js, wire.slot, wire.refs, rid, wire.retried)
+    wire = unsafe(g_media_wires?[rid])
+    if (wire != null && wire.submitted && !key_exists(g_wires, rid)) {   // answered with an error: no stream to wait on
+        drop_media_wire(rid, true)
+    }
+}
+
+//! A stream finished `media_lost`: the prefix cache no longer held a span the request sent no rows for. Encode every
+//! part and submit again, once. False where there is nothing to retry.
+def private retry_lost_media(rid : int64) : bool {
+    var wire = unsafe(g_media_wires?[rid])
+    return false if (wire == null || wire.retried)
+    wire.retried = true
+    wire.submitted = false
+    var why = ""
+    to_log(LOG_INFO, "[req {rid}] a span the prefix cache no longer holds: encoding the request's media\n")
+    return encode_media_refs(rid, *wire, true, why) && wire.jobs_left > 0
+}
+
 // everything after the media boundary: re-derives the request fields from `js` (cheap), renders,
 // and registers. Runs synchronously for a text request; an image request re-enters here from
 // drain_media_events with the worker's rows.
 def private handle_chat_tail(srv : FrontLink; writer : WriterRef; js : JsonValue?;   // nolint:STYLE037,STYLE038 — flat request-field derivation: one guard and one client-facing message per field
-                             slot : int; var media : array<float>; n_media : int64;
-                             media_is_audio : bool = false; resume_rid : int64 = 0l;
-                             media_grid : int2 = int2(0)) {
+                             slot : int; var refs : array<MediaRef>; resume_rid : int64 = 0l; resumed : bool = false) {
     g_cur = slot
     let msgs_v = js?["messages"]
     let streaming = js?["stream"] ?? false
@@ -3378,18 +3482,17 @@ def private handle_chat_tail(srv : FrontLink; writer : WriterRef; js : JsonValue
     var call_close = ""
     var think_stream = ThinkStream()
     var wire_tool_mode = ToolMode.none
-    var media_at = 0l
     var stable_at = 0l
     var start = 0
     while (true) {
         let render_error = render_chat_suffix(msgs_v, system, tools, max_new, start, think_set, think_val,
-                                              n_media > 0l, media_is_audio, prompt, stop_ids, close, nothink, call_open, call_close,
-                                              think_stream, wire_tool_mode, media_at, stable_at)
+                                              refs, prompt, stop_ids, close, nothink, call_open, call_close,
+                                              think_stream, wire_tool_mode, stable_at)
         if (!empty(render_error)) {
             bad_request(srv, writer, render_error)
             return
         }
-        let required = long_length(prompt) + n_media + (truncation == "auto" ? max_new : 1l)
+        let required = long_length(prompt) + (truncation == "auto" ? max_new : 1l)
         if (required <= cur_model().config.seq_len || truncation != "auto") {
             break
         }
@@ -3406,10 +3509,61 @@ def private handle_chat_tail(srv : FrontLink; writer : WriterRef; js : JsonValue
         delete nothink
         delete close
     }
-    register_request(srv, writer, prompt, stop_ids, close, media, media_at, n_media, params, max_new,
+    if (resume_rid != 0l && g_media_cover_probe && uncovered_media(prompt, refs)) {
+        // a part this slot knows, under a prompt whose cached prefix stops short of it: the worker encodes it, and
+        // the request resumes here with its rows
+        var wire = unsafe(g_media_wires?[resume_rid])
+        var why = ""
+        if (wire != null && encode_media_refs(resume_rid, *wire, false, why) && wire.jobs_left > 0) {
+            wire.submitted = false
+            return
+        }
+    }
+    var spans <- media_spans(prompt, refs)
+    register_request(srv, writer, prompt, stop_ids, close, spans, params, max_new,
                      streaming, true, "chatcmpl",
                      has_tools, call_open, call_close, seed, think_stream, wire_tool_mode, resume_rid,
-                     media_is_audio, media_grid, nothink, stable_at, wants_usage(js))
+                     nothink, stable_at, wants_usage(js), resumed)
+}
+
+//! Marks the refs that bring no rows and whose span the slot's prefix cache does not hold under `prompt`; true when
+//! there is one. A flat (unpaged) scheduler holds nothing, so every rowless ref is marked.
+def private uncovered_media(prompt : array<int64>; var refs : array<MediaRef>) : bool {
+    let covered = cur_sched().paged ? prefix_match_len(cur_sched().prefix, cur_sched().pool, prompt) : 0l
+    var any = false
+    var from = 0l
+    for (r in refs) {
+        let first = media_position_id(r.key, 0l)
+        var at = from
+        while (at < long_length(prompt) && prompt[at] != first) {
+            at++
+        }
+        continue if (at >= long_length(prompt))
+        from = at + r.n_rows
+        if (empty(r.rows) && from > covered) {
+            r.want_rows = true
+            any = true
+        }
+    }
+    return any
+}
+
+//! The spans of a rendered prompt: each ref's run of position ids, in prompt order, with the ref's rows moved in. A ref
+//! whose message the renderer dropped (auto truncation) has no run and makes no span.
+def private media_spans(prompt : array<int64>; var refs : array<MediaRef>) : array<MediaSpan> {
+    var spans : array<MediaSpan>
+    var from = 0l
+    for (r in refs) {
+        let first = media_position_id(r.key, 0l)
+        var at = from
+        while (at < long_length(prompt) && prompt[at] != first) {
+            at++
+        }
+        continue if (at >= long_length(prompt))
+        spans |> emplace(MediaSpan(at = at, n = r.n_rows, non_causal = !r.is_audio, grid = r.grid, rows <- r.rows))
+        from = at + r.n_rows
+    }
+    return <- spans
 }
 
 //! whether a request asks its stream to end on the usage chunk (`stream_options.include_usage`)
@@ -3444,8 +3598,8 @@ def private handle_completion(srv : FrontLink; req : FrontReq; writer : WriterRe
     // no stop ids and no close: raw completions run to the budget, matching bare generate()
     var none_stop : array<int64>
     var none_close : array<int64>
-    var no_media : array<float>
-    register_request(srv, writer, toks, none_stop, none_close, no_media, 0l, 0l,
+    var no_spans : array<MediaSpan>
+    register_request(srv, writer, toks, none_stop, none_close, no_spans,
                      params, max_new, streaming, false, "cmpl",
                      [seed = seed, include_usage = wants_usage(js)])
 }
@@ -3490,12 +3644,7 @@ def private reap_disconnected(srv : FrontLink) {
     reap_speech_wires(srv)
     var disconnected_vision <- gone_wires(srv, g_media_wires)
     for (id in disconnected_vision) {
-        unsafe {
-            delete g_media_wires[id].js
-        }
-        g_media_wires[id].js = null
-        delete g_media_wires[id]
-        g_media_wires |> erase(id)
+        drop_media_wire(id, true)
     }
     delete disconnected_vision
 }
@@ -3573,6 +3722,12 @@ def private flush_events(srv : FrontLink) {   // nolint:STYLE037,STYLE038 — on
             continue
         }
         g_cur = w.slot   // response builders read the wire's slot (cur_name / cur_model)
+        if (e.kind != SchedEventKind.piece && e.finish == "media_lost" && retry_lost_media(e.stream)) {
+            delete g_wires[e.stream]   // the retry registers the stream's wire again, under the same id
+            g_wires |> erase(e.stream)
+            continue
+        }
+        drop_media_wire(e.stream, true)   // the stream is under way: its parked request has nothing left to retry
         if (e.kind == SchedEventKind.piece) {
             if (!w.streaming || w.has_tools) {
                 w.reply_parts |> push(e.text)   // buffered reply, and/or the finish-time tool-call parse
@@ -3817,6 +3972,15 @@ def private tts_stats_member() : string {
     return ",\"tts\":\{\"id\":{json_str(m.id)},\"ready\":{m.ready > 0},\"pending\":{g_tts_pending},\"done_jobs\":{g_tts_done_jobs},\"audio_s\":{g_tts_audio_s},\"voices\":[{voices}],\"sample_rate\":{m.sample_rate},\"lane\":{json_str(lane)},\"cloning\":{m.cloning},\"speed\":{m.speed},\"lang\":{json_str(m.lang)}{models}{failed}}"
 }
 
+//! the stats answer's `asr` member: each served ASR model with its workers and where they decode; "" with none
+def private asr_stats_member() : string {
+    return "" if (empty(g_asr))
+    var models <- [for (a in g_asr); "\{\"id\":{json_str(a.id)},\"workers\":{a.workers},\"ready\":{a.ready},\"decoder\":{json_str(a.decoder)}}"]
+    let member = ",\"asr\":\{\"models\":[{join(models, ",")}]}"
+    delete models
+    return member
+}
+
 // splice a member into a compact JSON object body: sprint_json/write_json_compact both close on
 // the final `}`, and the stats shapes are objects with at least one member
 def private with_json_member(body : string; member : string) : string {
@@ -3832,7 +3996,7 @@ def private handle_stats(var resp : Reply) : http_status {
         // `setup` is the MODE, not the slot count — a speech-only server serves the speech route
         // and must not draw the page's pick-a-model surface.
         return resp |> JSON(
-            "\{\"setup\":{g_setup_mode},\"model\":\"(no model)\",\"active_model\":\"\",\"ctx\":0,\"uptime_s\":{g_started_at > 0l ? get_time_nsec(g_started_at) / 1_000_000_000l : 0l},\"draining\":{g_shutdown_requested},\"active\":0,\"queued\":0,\"peak_active\":0,\"admitted\":0,\"finished\":0,\"evicted\":0,\"decode_steps\":0,\"gen_tokens\":0,\"avg_batch\":0,\"cached_tokens\":0,\"prefix_pages\":0,\"max_streams\":0,\"chunk_tokens\":0,\"asr_workers\":0,\"asr_ready\":0,\"asr_active\":0,\"asr_pending\":0,\"mtp_drafted\":0,\"mtp_accepted\":0,\"prefill_tokens\":0,\"ttft_avg_ms\":0,\"ttft_last_ms\":0,\"weights_bytes\":0,\"kv_bytes\":0,\"gpu_vram_bytes\":0,\"gpu_budget_bytes\":0,\"hardware\":{json_str(g_hardware_line)},\"asr_done_jobs\":0,\"asr_audio_s\":0,\"tts_done_jobs\":{g_tts_done_jobs},\"tts_audio_s\":{g_tts_audio_s},\"vision\":false,\"audio\":false,\"models\":[]{tts_stats_member()}}",
+            "\{\"setup\":{g_setup_mode},\"model\":\"(no model)\",\"active_model\":\"\",\"ctx\":0,\"uptime_s\":{g_started_at > 0l ? get_time_nsec(g_started_at) / 1_000_000_000l : 0l},\"draining\":{g_shutdown_requested},\"active\":0,\"queued\":0,\"peak_active\":0,\"admitted\":0,\"finished\":0,\"evicted\":0,\"decode_steps\":0,\"gen_tokens\":0,\"avg_batch\":0,\"cached_tokens\":0,\"prefix_pages\":0,\"max_streams\":0,\"chunk_tokens\":0,\"asr_workers\":{[for (a in g_asr); a.workers] |> sum()},\"asr_ready\":{[for (a in g_asr); a.ready] |> sum()},\"asr_active\":{g_asr_active},\"asr_pending\":{g_asr_pending},\"mtp_drafted\":0,\"mtp_accepted\":0,\"prefill_tokens\":0,\"ttft_avg_ms\":0,\"ttft_last_ms\":0,\"weights_bytes\":0,\"kv_bytes\":0,\"gpu_vram_bytes\":0,\"gpu_budget_bytes\":0,\"hardware\":{json_str(g_hardware_line)},\"asr_done_jobs\":{g_asr_done_jobs},\"asr_audio_s\":{g_asr_audio_s},\"tts_done_jobs\":{g_tts_done_jobs},\"tts_audio_s\":{g_tts_audio_s},\"vision\":false,\"audio\":false,\"models\":[]{asr_stats_member()}{tts_stats_member()}}",
             http_status.OK)
     }
     let tier = gpu_tier_status()
@@ -3901,7 +4065,7 @@ def private handle_stats(var resp : Reply) : http_status {
     }
     let body = sprint_json(out, false)
     delete out
-    return resp |> JSON(with_json_member(body, tts_stats_member()), http_status.OK)
+    return resp |> JSON(with_json_member(body, "{asr_stats_member()}{tts_stats_member()}"), http_status.OK)
 }
 
 // /v1/streams: the poll surface behind the page's swimlane + stream cards — per-stream state,
@@ -3974,7 +4138,7 @@ def private handle_streams(var resp : Reply) : http_status {
                 id = st.id, model = mname,
                 state = st.state == StreamState.prefilling ? "prefilling" : "decoding",
                 age_s = age_seconds(st.t_admit),
-                n_prompt = long_length(st.prompt) + st.n_media, n_cached = st.n_cached,
+                n_prompt = long_length(st.prompt), n_cached = st.n_cached,
                 n_prefilled = st.n_prefilled, n_gen = st.n_gen, max_new = st.max_new,
                 ttft_ms = float(st.ttft_us) / 1000.0,
                 prompt_head = st.prompt_head, gen_tail = utf8_trim_partial_end(string(st.gen_tail_bytes))))
@@ -3983,7 +4147,7 @@ def private handle_streams(var resp : Reply) : http_status {
             out.streams |> push(OaiStreamInfo(
                 id = q.id, model = mname, state = "queued",
                 age_s = q.t_submit != 0l ? age_seconds(q.t_submit) : 0.0,
-                n_prompt = long_length(q.prompt) + q.n_media, max_new = q.max_new))
+                n_prompt = long_length(q.prompt), max_new = q.max_new))
         }
         for (d in sch.recent_done) {
             out.streams |> push(OaiStreamInfo(
@@ -4026,14 +4190,14 @@ let private CONFIG_KEY_KINDS <- {
     "ctx" => "i", "max_tokens" => "i", "streams" => "i", "threads" => "i", "team_dispatch" => "s",
     "affinity" => "i", "chunk" => "i", "chunk_idle" => "i", "page_rows" => "i", "prefix" => "i", "flat" => "b",
     "mtp" => "b", "rope_scaling" => "s", "rope_scale" => "f", "yarn_orig_ctx" => "i",
-    "lcpp_bin" => "s", "models_dir" => "s", "image_mmproj" => "s", "models" => "a",
+    "lcpp_bin" => "s", "models_dir" => "s", "image_mmproj" => "s", "audio_mmproj" => "s", "models" => "a",
     "exchange_url" => "s", "exchange_accept" => "s", "exchange_submit" => "s"
 }
 
 let private MODEL_KEY_KINDS <- {
     "name" => "s", "path" => "s", "backend" => "s", "ctx" => "i", "quant" => "s",
     "kv_dtype" => "s", "streams" => "i", "chunk" => "i", "chunk_idle" => "i", "page_rows" => "i", "prefix" => "i",
-    "mtp" => "b", "default" => "b", "image_mmproj" => "s",
+    "mtp" => "b", "default" => "b", "image_mmproj" => "s", "audio_mmproj" => "s",
     "rope_scaling" => "s", "rope_scale" => "f", "yarn_orig_ctx" => "i"
 }
 
@@ -4641,14 +4805,18 @@ def private asr_worker_main(
                             worker_index : int;
                             model_path, mmproj_path : string;
                             team_dispatch : bool;
+                            metal : MetalMode;
                             var jobs : Channel?&;
                             var events : Channel?&
                             ) {
     this_context().name := "dasllama_asr_{worker_index}"
     configure_media_worker_dispatch(team_dispatch)
-    // the engine's Metal mode is the engine context's: this one starts with none, and a family whose decoder is an
-    // LLM (Qwen3-ASR, Canary) prefills it here on the CPU arm - a legitimate serving configuration, not a profiling slip
-    allow_cpu_prefill()
+    // a two-file model's decoder is a Model session and takes the engine's Metal mode; a one-file model (whisper,
+    // parakeet) decodes on hand-written CPU loops over planar weights, which the mode's portable pin would slow
+    if (!empty(mmproj_path)) {
+        set_metal_mode(metal)
+    }
+    allow_cpu_prefill()   // a decline lands the decoder's prefill on the CPU arm: served, not a profiling slip
     var model = AsrModel()
     var load_failure = ""
     let load_failed = catch_worker_panic(load_failure) {
@@ -4661,7 +4829,7 @@ def private asr_worker_main(
         events |> release
         return
     }
-    emit_asr_event(events, AsrEvent(kind = AsrEventKind.ready))
+    emit_asr_event(events, AsrEvent(kind = AsrEventKind.ready, body = model.dec.metal_blob ? "metal" : "cpu"))
     var session = AsrSession()
     var session_language = ""
     var has_session = false
@@ -4765,12 +4933,13 @@ def private start_asr_worker_threads() {
             let model_path = a.path
             let mmproj_path = a.mmproj
             let team_dispatch = g_asr_team_dispatch
+            let metal = g_speech_metal
             var jobs_capture = jobs
             var events_capture = g_asr_events
-            new_thread() <| @capture(= worker_index, = model_path, = mmproj_path, = team_dispatch,
+            new_thread() <| @capture(= worker_index, = model_path, = mmproj_path, = team_dispatch, = metal,
                                     = jobs_capture, = events_capture) {
                 asr_worker_main(
-                    worker_index, model_path, mmproj_path, team_dispatch, jobs_capture, events_capture)
+                    worker_index, model_path, mmproj_path, team_dispatch, metal, jobs_capture, events_capture)
             }
             index++
         }
@@ -4779,7 +4948,8 @@ def private start_asr_worker_threads() {
             g_asr_events |> pop_with_timeout_clone(1000) $(event : AsrEvent#) {
                 if (event.kind == AsrEventKind.ready) {
                     a.ready++
-                    to_log(LOG_INFO, "dasllama-server: ASR worker ready ({a.id}: {a.ready}/{a.workers})\n")
+                    a.decoder = clone_string(event.body)
+                    to_log(LOG_INFO, "dasllama-server: ASR worker ready ({a.id}: {a.ready}/{a.workers}, decoder on {a.decoder})\n")
                 } elif (event.kind == AsrEventKind.failed) {
                     load_failure = clone_string(event.body)
                 }
@@ -5453,12 +5623,24 @@ struct private MediaEvent {
 
 struct private MediaWire {
     @do_not_delete writer : WriterRef
-    @do_not_delete js : JsonValue?   // the parked parsed request — drain_media_events deletes it explicitly
+    @do_not_delete js : JsonValue?   // the parked parsed request — `drop_media_wire` deletes it explicitly
     slot : int
-    is_audio : bool                  // picks the render span (audio vs image) and the causal splice
+    refs : array<MediaRef>           // the request's media parts, in transcript order
+    jobs_left : int                  // encode jobs the worker still owes this request
+    failed : string                  // the first job failure's reason
+    submitted : bool                 // rendered and handed to the scheduler: kept only for a lost span's retry
+    retried : bool                   // a lost span was retried once already
 }
 
-let MEDIA_QUEUE_LIMIT = 8   // parked image requests are heavy (decoded bytes ride the channel)
+//! which ref of which parked request an encode job serves
+struct private MediaJobRef {
+    wire : int64
+    at : int
+}
+
+var private g_media_job_ref : table<int64; MediaJobRef>
+
+let MEDIA_QUEUE_LIMIT = MEDIA_SPANS_LIMIT   //!< encode jobs queued or in flight, a job a new part: one request's parts fill it alone (decoded bytes ride the channel)
 
 let GEMMA4A_AUDIO_SOFT_TOKENS_PER_SEC = 25l
 let AUDIO_DECODE_SAMPLE_RATE = 16000l
@@ -5474,6 +5656,15 @@ var private g_media_jobs : Channel?
 var private g_media_events : Channel?
 var private g_media_wires : table<int64; MediaWire>
 var private g_media_rows = 0l   // media (image span) rows admitted to prefill since boot
+var private g_media_cover_probe = true
+
+//! Whether a rowless part's span is looked up in the prefix cache before the request is submitted (the default). Off,
+//! every known part goes to the scheduler rowless and a span the cache does not hold comes back `media_lost` - the
+//! route a span evicted between the lookup and the admission takes. Non-private: test_openai_server_audio.das gates
+//! the retry through it.
+def set_media_cover_probe(on : bool) {
+    g_media_cover_probe = on
+}
 var private g_media_ready = 0
 var private g_media_armed = false
 var private g_media_pending = 0   // encode jobs queued or in flight; the wire table undercounts
@@ -5666,33 +5857,43 @@ def private drain_media_events(srv : FrontLink) {
             var ev : MediaEvent
             ev := event
             defer() { delete ev }
-            // interior pointer into g_media_wires — nothing inserts into the table between here
-            // and the erase (the only insert is handle_chat's park, and handlers cannot run inside
-            // this drain)
-            var wire = unsafe(g_media_wires?[ev.id])
+            let jr = g_media_job_ref?[ev.id] ?? MediaJobRef()
+            g_media_job_ref |> erase(ev.id)
+            // interior pointer into g_media_wires — nothing inserts into the table inside this drain
+            var wire = unsafe(g_media_wires?[jr.wire])
             if (wire == null) {
                 return   // the client vanished while encoding; reap released the writer
             }
-            if (!is_writer_connected(srv, wire.writer)) {
-                release_writer(srv, wire.writer)
-            } elif (!ev.ok) {
-                bad_request(srv, wire.writer, ev.why)
-            } elif (reject_deferred_while_draining(srv, wire.writer)) {
-                pass   // a clean terminal 503: the drain must not admit a new generation
+            wire.jobs_left--
+            if (!ev.ok) {
+                wire.failed = empty(wire.failed) ? ev.why : wire.failed
             } else {
                 if (ev.is_audio) {
-                    to_log(LOG_INFO, "[req {ev.id}] audio {float(ev.audio_cs) / 100f}s -> {ev.n_media} soft tokens in {ev.enc_ms}ms off-thread\n")
+                    to_log(LOG_INFO, "[req {jr.wire}] audio {float(ev.audio_cs) / 100f}s -> {ev.n_media} soft tokens in {ev.enc_ms}ms off-thread\n")
                 } else {
-                    to_log(LOG_INFO, "[req {ev.id}] image {ev.width}x{ev.height} -> {ev.n_media} soft tokens in {ev.enc_ms}ms off-thread\n")
+                    to_log(LOG_INFO, "[req {jr.wire}] image {ev.width}x{ev.height} -> {ev.n_media} soft tokens in {ev.enc_ms}ms off-thread\n")
+                }
+                wire.refs[jr.at].n_rows = ev.n_media
+                wire.refs[jr.at].grid = ev.grid
+                delete wire.refs[jr.at].rows
+                wire.refs[jr.at].rows <- ev.rows
+                if (length(g_media_seen) >= MEDIA_SEEN_LIMIT) {
+                    g_media_seen |> clear()
                 }
-                handle_chat_tail(srv, wire.writer, wire.js, wire.slot, ev.rows, ev.n_media, ev.is_audio, ev.id, ev.grid)
+                g_media_seen[wire.refs[jr.at].key] = MediaSeen(n_rows = ev.n_media, grid = ev.grid)
             }
-            unsafe {
-                delete wire.js
+            return if (wire.jobs_left > 0)
+            if (!is_writer_connected(srv, wire.writer)) {
+                release_writer(srv, wire.writer)
+                drop_media_wire(jr.wire, true)
+            } elif (!empty(wire.failed)) {
+                bad_request(srv, wire.writer, wire.failed)
+                drop_media_wire(jr.wire, true)
+            } elif (reject_deferred_while_draining(srv, wire.writer)) {
+                drop_media_wire(jr.wire, true)   // a clean terminal 503: the drain must not admit a new generation
+            } else {
+                resume_media_request(srv, jr.wire)
             }
-            wire.js = null
-            delete g_media_wires[ev.id]
-            g_media_wires |> erase(ev.id)
         }
     }
 }
@@ -6176,6 +6377,7 @@ struct private SpeechBoot {
     asr_team : bool
     tts_team : bool
     asr_alias : string
+    metal : MetalMode
 }
 
 //! the speech state the engine's status routes and its drain read
@@ -6265,6 +6467,7 @@ def private speech_main(var boot : Channel?&; var inbox : Channel?&; var to_engi
         g_tts := b.tts
         g_asr_team_dispatch = b.asr_team
         g_tts_team_dispatch = b.tts_team
+        g_speech_metal = b.metal
         g_asr_alias = clone_string(b.asr_alias)
     }
     boot |> release
@@ -6371,7 +6574,7 @@ def private start_speech_thread {
     g_speech_out = worker_channel()
     var boot = worker_channel()
     g_asr_alias = empty(g_slots) ? "" : "{g_slots[g_default_slot].name}-asr"
-    var first = SpeechBoot(asr_team = g_asr_team_dispatch, tts_team = g_tts_team_dispatch, asr_alias = g_asr_alias)
+    var first = SpeechBoot(asr_team = g_asr_team_dispatch, tts_team = g_tts_team_dispatch, asr_alias = g_asr_alias, metal = get_metal_mode())
     first.asr := g_asr
     first.tts := g_tts
     boot |> push_clone(first)
@@ -6605,8 +6808,8 @@ def init_server(port : int; max_streams : int64 = 4l; max_queue : int64 = 32l; c
         to_log(LOG_ERROR, "dasllama-server: init_server called while already initialized\n")
         return false
     }
-    if (empty(g_slots) && !g_setup_mode && !server_has_tts()) {
-        to_log(LOG_ERROR, "dasllama-server: init_server with no model slots (call set_model/add_model first, or configure_tts for a speech-only server)\n")
+    if (empty(g_slots) && !g_setup_mode && !server_has_speech()) {
+        to_log(LOG_ERROR, "dasllama-server: init_server with no model slots (call set_model/add_model first, or add_tts_model / add_asr_model for a speech-only server)\n")
         return false
     }
     g_shutdown_requested = false   // reset so a restart in the same context after /shutdown doesn't drain at once
@@ -6629,7 +6832,7 @@ def init_server(port : int; max_streams : int64 = 4l; max_queue : int64 = 32l; c
     g_media_events = worker_channel()
     init_worker_rails()
     if (empty(g_slots)) {
-        if (!g_setup_mode && !server_has_tts()) {
+        if (!g_setup_mode && !server_has_speech()) {
             // the speech-only boot's worker dropped the route as it loaded: the catalog/config
             // page is all that is left to serve, and it is where the config gets fixed
             to_log(LOG_WARNING, "dasllama-server: the speech route did not arm and no model is loaded - falling back to setup mode\n")
diff --git a/utils/dasllama-server/test_cli_args.das b/utils/dasllama-server/test_cli_args.das
index ccf48fad8a..d4c1648b72 100644
--- a/utils/dasllama-server/test_cli_args.das
+++ b/utils/dasllama-server/test_cli_args.das
@@ -285,7 +285,7 @@ def test_config_speech_roster(t : T?) {
 
 [test]
 def test_config_file(t : T?) {
-    let body = "model = \"a.gguf\"\ngpu = \"vulkan\"\ngpu_layers = 3\nthreads = 6\nasr = \"asr.bin\"\ntts = \"t.gguf\"\nimage_mmproj = \"v.gguf\"\nmodels_dir = \"/m\"\n"
+    let body = "model = \"a.gguf\"\ngpu = \"vulkan\"\ngpu_layers = 3\nthreads = 6\nasr = \"asr.bin\"\ntts = \"t.gguf\"\nimage_mmproj = \"v.gguf\"\naudio_mmproj = \"au.gguf\"\nmodels_dir = \"/m\"\n"
     t |> run("the flat keys land") @(t : T?) {
         var cfg = CliConfig()
         t |> success(parse_cli_config(body, cfg), "parses")
@@ -299,14 +299,16 @@ def test_config_file(t : T?) {
         t |> equal(cfg.asr, "asr.bin")
         t |> equal(cfg.tts, "t.gguf")
         t |> equal(cfg.image_mmproj, "v.gguf")
+        t |> equal(cfg.audio_mmproj, "au.gguf")
         t |> equal(cfg.models_dir, "/m")
     }
     t |> run("a roster's default entry supplies the model and its overrides") @(t : T?) {
-        let roster = "gpu = \"off\"\n[[models]]\npath = \"first.gguf\"\n[[models]]\npath = \"second.gguf\"\ndefault = true\nimage_mmproj = \"v2.gguf\"\nctx = 2048\nquant = \"q4_k\"\n"
+        let roster = "gpu = \"off\"\n[[models]]\npath = \"first.gguf\"\n[[models]]\npath = \"second.gguf\"\ndefault = true\nimage_mmproj = \"v2.gguf\"\naudio_mmproj = \"au2.gguf\"\nctx = 2048\nquant = \"q4_k\"\n"
         var cfg = CliConfig()
         t |> success(parse_cli_config(roster, cfg), "parses")
         t |> equal(cfg.model, "second.gguf")
         t |> equal(cfg.image_mmproj, "v2.gguf")
+        t |> equal(cfg.audio_mmproj, "au2.gguf")
         t |> equal(cfg.ctx, 2048)
         t |> equal(cfg.quant, "q4_k")
     }
@@ -317,6 +319,9 @@ def test_config_file(t : T?) {
         var flat = CliConfig()
         t |> success(parse_cli_config("model = \"flat.gguf\"\n[[models]]\npath = \"first.gguf\"\n", flat), "parses")
         t |> equal(flat.model, "flat.gguf")
+        var flat_audio = CliConfig()
+        t |> success(parse_cli_config("audio_mmproj = \"flat.gguf\"\n[[models]]\npath = \"first.gguf\"\naudio_mmproj = \"entry.gguf\"\n", flat_audio), "parses")
+        t |> equal(flat_audio.audio_mmproj, "flat.gguf", "a flat audio_mmproj wins over the roster entry's")
     }
     t |> run("bad TOML is the error, not a silent empty config") @(t : T?) {
         var cfg = CliConfig()
diff --git a/utils/dasllama-server/test_openai_server.das b/utils/dasllama-server/test_openai_server.das
index 7da92c8a35..1f376eecf8 100644
--- a/utils/dasllama-server/test_openai_server.das
+++ b/utils/dasllama-server/test_openai_server.das
@@ -289,11 +289,10 @@ def test_openai_server(t : T?) {   // nolint:STYLE038 — one live server sessio
                 t |> equal(int(resp.status_code), int(http_status.BAD_REQUEST))
                 t |> success(find(string(resp.body), "no audio arm") >= 0, "the 400 names the missing audio arm")
             }
-            // an image AND audio in one message: refused by shape before any arm check — the
-            // scheduler takes ONE media splice per request
+            // an image AND audio in one message: a request may carry both, so the refusal here is the missing arm
             POST("{base_url}/v1/chat/completions", "\{\"messages\":[\{\"role\":\"user\",\"content\":[\{\"type\":\"image_url\",\"image_url\":\{\"url\":\"data:image/png;base64,AAAA\"}},\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"AAAA\",\"format\":\"wav\"}}]}]}") $(resp) {
                 t |> equal(int(resp.status_code), int(http_status.BAD_REQUEST))
-                t |> success(find(string(resp.body), "image AND audio") >= 0, "the 400 names the two-media shape")
+                t |> success(find(string(resp.body), " arm ") >= 0, "the 400 names a missing arm")
             }
             // /v1/stats declares the arms the page reads: the vision/audio flags and the thinking default
             GET("{base_url}/v1/stats") $(resp) {
@@ -363,7 +362,7 @@ def test_openai_server(t : T?) {   // nolint:STYLE038 — one live server sessio
                 }
             }
             // POST /config — validated body writes an authoritative TOML to the registered path
-            POST("{base_url}/config", "\{\"model\":\"m.gguf\",\"port\":8123,\"mtp\":true,\"gpu\":\"vulkan\",\"image_mmproj\":\"mm.gguf\",\"tts_voices_dir\":\"voices\",\"chunk_idle\":1024}") $(resp) {
+            POST("{base_url}/config", "\{\"model\":\"m.gguf\",\"port\":8123,\"mtp\":true,\"gpu\":\"vulkan\",\"image_mmproj\":\"mm.gguf\",\"audio_mmproj\":\"am.gguf\",\"tts_voices_dir\":\"voices\",\"chunk_idle\":1024}") $(resp) {
                 t |> equal(int(resp.status_code), int(http_status.OK))
                 t |> success(find(string(resp.body), "restart_required") >= 0, "save response flags restart")
             }
@@ -379,6 +378,7 @@ def test_openai_server(t : T?) {   // nolint:STYLE038 — one live server sessio
                     t |> equal(troot?["model"] ?? "", "m.gguf")
                     t |> success(troot?["mtp"] ?? false, "bool key round-trips")
                     t |> equal(troot?["image_mmproj"] ?? "", "mm.gguf")   // a save must not eat the vision arm
+                    t |> equal(troot?["audio_mmproj"] ?? "", "am.gguf")   // nor the audio arm
                     t |> equal(troot?["tts_voices_dir"] ?? "", "voices")   // every key the page's field list carries is a key the save takes
                     t |> equal(troot?["chunk_idle"] ?? 0l, 1024l)
                     unsafe {
@@ -731,7 +731,7 @@ def test_bench_inprocess(t : T?) {   // nolint:STYLE038 — one live server sess
     }
 }
 
-let TEST_PORT_HELD = 18161   // 18150-18156 are test_openai_server_mtp.das's, 18170-18174 test_openai_server_speech_multi.das's
+let TEST_PORT_HELD = 18161   // 18150-18156 are test_openai_server_mtp.das's, 18170-18176 test_openai_server_speech_multi.das's
 
 //! The HTTP front answers a status route from the engine's last answer while a handler holds the engine: an embeddings
 //! forward over a long input runs in-handler for hundreds of milliseconds, and /v1/stats still answers in a fraction of
diff --git a/utils/dasllama-server/test_openai_server_audio.das b/utils/dasllama-server/test_openai_server_audio.das
index bbd92c022b..b356365e7c 100644
--- a/utils/dasllama-server/test_openai_server_audio.das
+++ b/utils/dasllama-server/test_openai_server_audio.das
@@ -13,6 +13,7 @@ require daslib/json_boost                               // read_json
 require daslib/base64                                   // input_audio.data payload
 require daslib/fio
 require strings
+require daslib/strings_boost                            // count / join
 
 // NATIVE AUDIO through the serving slot: input_audio part -> media worker gemma4a encode -> soft
 // tokens spliced (causal) between the audio span markers -> the model transcribes/answers. ONE
@@ -93,6 +94,30 @@ def private audio_chat_body(b64 : string; text : string) : string {
     return "\{\"messages\":[\{\"role\":\"user\",\"content\":[\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"{b64}\",\"format\":\"wav\"}},\{\"type\":\"text\",\"text\":\"{text}\"}]}]}"
 }
 
+//! what a buffered chat reply says: its prompt and cached position counts, its finish reason, its content
+struct private ChatReply {
+    prompt : int
+    cached : int
+    finish : string
+    content : string
+}
+
+def private usage_of(t : T?; body : string; tag : string) : ChatReply {
+    var err : string
+    var js = read_json(body, err)
+    t |> success(js != null, "{tag}: chat JSON parses")
+    return ChatReply() if (js == null)
+    let res = ChatReply(prompt = int(js?["usage"]?["prompt_tokens"] ?? 0l),
+                        cached = int(js?["usage"]?["prompt_tokens_details"]?["cached_tokens"] ?? 0l),
+                        finish = js?["choices"]?[0]?["finish_reason"] ?? "",
+                        content = js?["choices"]?[0]?["message"]?["content"] ?? "")
+    to_log(LOG_INFO, "{tag}: prompt {res.prompt}, cached {res.cached}, finish {res.finish}, reply '{res.content}'\n")
+    unsafe {
+        delete js
+    }
+    return res
+}
+
 [test]
 def test_openai_server_audio(t : T?) {   // nolint:STYLE038 — one live server session per test: every endpoint assertion runs against that one boot
     t |> run("native audio: input_audio -> gemma4a soft tokens -> a transcription (needs E2B + its mmproj)") @(t : T?) {
@@ -139,11 +164,28 @@ def test_openai_server_audio(t : T?) {   // nolint:STYLE038 — one live server
                     }
                 }
             }
-            // an image AND audio on the ARMED slot: still refused by shape — one media splice per request
+            // an image AND audio on the ARMED slot: both parts reach the worker, and the bytes that are no image answer the 400
             POST("{base_url}/v1/chat/completions",
                  "\{\"messages\":[\{\"role\":\"user\",\"content\":[\{\"type\":\"image_url\",\"image_url\":\{\"url\":\"data:image/png;base64,AAAA\"}},\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"{slice(b64, 0, 64)}\",\"format\":\"wav\"}}]}]}") $(resp) {
                 t |> equal(int(resp.status_code), int(http_status.BAD_REQUEST))
-                t |> success(find(string(resp.body), "image AND audio") >= 0, "the 400 names the two-media shape")
+                t |> success(find(string(resp.body), "did not decode") >= 0 || find(string(resp.body), "decode") >= 0, "the 400 names the part that does not decode")
+            }
+            // the clip's cost is paid once: asked again, and continued with the clip in the history, the request attaches
+            // the clip's span off the prefix cache and never reaches the tower
+            let ask = "\{\"max_tokens\":8,\"messages\":[\{\"role\":\"user\",\"content\":[\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"{b64}\",\"format\":\"wav\"}},\{\"type\":\"text\",\"text\":\"Transcribe this audio.\"}]}"
+            var first_prompt = 0
+            POST("{base_url}/v1/chat/completions", "{ask}]}") $(resp) {
+                let u = usage_of(t, string(resp.body), "the clip asked again")
+                first_prompt = u.prompt
+                t |> success(u.cached >= u.prompt - 1 && u.prompt > 40, "asked again, all but the last position attaches ({u.cached} of {u.prompt})")
+            }
+            POST("{base_url}/v1/chat/completions", "{ask},\{\"role\":\"assistant\",\"content\":\"ok\"},\{\"role\":\"user\",\"content\":\"Thanks.\"}]}") $(resp) {
+                let u = usage_of(t, string(resp.body), "the chat continued")
+                t |> success(u.prompt > first_prompt, "the continued chat keeps the clip in its transcript ({u.prompt} > {first_prompt} positions)")
+                t |> success(u.cached > 40 && u.cached <= first_prompt, "and attaches the first turn, the clip's span in it ({u.cached} of the first turn's {first_prompt})")
+            }
+            GET("{base_url}/v1/stats") $(resp) {
+                t |> success(find(string(resp.body), "media") >= 0, "stats still answers after the media turns")
             }
             // input_audio.data that is not base64: the synchronous 400
             POST("{base_url}/v1/chat/completions", audio_chat_body("!!!not-base64!!!", "hi")) $(resp) {
@@ -187,3 +229,309 @@ def test_openai_server_audio(t : T?) {   // nolint:STYLE038 — one live server
         }
     }
 }
+
+// A WHISPER-CLASS tower on a stock decoder: the ultravox mmproj arms Llama-3.2-1B's audio through the audio flag alone
+// (no vision tower in the file), its rows splice with no span marker, after the text the message puts ahead of them.
+
+let TOWER_PORT = 18177
+let UV_DEC_PATH = path_join(models_dir(), "Llama-3.2-1B-Instruct-Q8_0.gguf")
+let UV_MM_PATH = path_join(models_dir(), "mmproj-ultravox-v0_5-llama-3_2-1b-f16.gguf")
+let UV_ROWS = 187   // a chunk's soft tokens: 1500 encoder positions over the stack of 8
+
+//! `cover_probe` false sends every known part to the scheduler rowless (`set_media_cover_probe`)
+def private with_tower_audio_server(port : int; cover_probe : bool; blk : block<(base_url : string) : void>) {
+    with_job_status(1) $(finished) {
+        new_thread() @() {
+            allow_cpu_prefill()
+            var m <- load_model(UV_DEC_PATH, QuantMode.q8)
+            set_model(m, "test-uv")
+            set_model_audio("test-uv", UV_MM_PATH)
+            set_default_max_tokens(48l)
+            set_media_cover_probe(cover_probe)
+            run_server(port)
+            finished |> notify_and_release
+        }
+        let ready = serve_clients(port, 1200, "/v1/models", blk)
+        finished |> join
+        assert(ready, "dasllama tower-audio server became ready")
+    }
+}
+
+def private prompt_tokens_of(t : T?; body : string; tag : string) : int {
+    let reply = usage_of(t, body, tag)
+    t |> success(!empty(reply.content), "{tag}: the turn answers")
+    return reply.prompt
+}
+
+//! the scheduler's streams admitted and the media rows prefilled since boot, off /v1/stats
+def private stats_counts(t : T?; base_url : string) : tuple<admitted : int64; media_rows : int64> {
+    var res = (admitted = -1l, media_rows = -1l)
+    GET("{base_url}/v1/stats") $(resp) {
+        var err : string
+        var js = read_json(string(resp.body), err)
+        t |> success(js != null, "stats JSON parses")
+        if (js != null) {
+            res = (admitted = js?["admitted"] ?? -1l, media_rows = js?["media_rows"] ?? -1l)
+            unsafe {
+                delete js
+            }
+        }
+    }
+    return res
+}
+
+//! a greedy chat under the system line `system`: the clip then `text` in one user message, or `text` alone for an empty `b64`
+def private system_chat_body(system, b64, text : string; stream : bool) : string {
+    let audio = empty(b64) ? "" : "\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"{b64}\",\"format\":\"wav\"}},"
+    return "\{\"temperature\":0,\"stream\":{stream},\"messages\":[\{\"role\":\"system\",\"content\":\"{system}\"},\{\"role\":\"user\",\"content\":[{audio}\{\"type\":\"text\",\"text\":\"{text}\"}]}]}"
+}
+
+//! one ask of the clip under `system`: the reply, and how far the admitted-stream and media-row counters moved for it
+def private ask_counted(t : T?; base_url, system, b64, text : string; tag : string) : tuple<reply : ChatReply; admitted : int64; rows : int64> {
+    let before = stats_counts(t, base_url)
+    var reply = ChatReply()
+    POST("{base_url}/v1/chat/completions", system_chat_body(system, b64, text, false)) $(resp) {
+        t |> equal(int(resp.status_code), int(http_status.OK), "{tag}: {resp.body}")
+        reply = usage_of(t, string(resp.body), tag)
+    }
+    let after = stats_counts(t, base_url)
+    return (reply = reply, admitted = after.admitted - before.admitted, rows = after.media_rows - before.media_rows)
+}
+
+//! the prompt positions `text` alone takes under `system`
+def private text_prompt(t : T?; base_url, system, text : string) : int {
+    var n = 0
+    POST("{base_url}/v1/chat/completions", system_chat_body(system, "", text, false)) $(resp) {
+        t |> equal(int(resp.status_code), int(http_status.OK))
+        n = prompt_tokens_of(t, string(resp.body), "text alone under '{system}'")
+    }
+    return n
+}
+
+[test]
+def test_openai_server_audio_tower(t : T?) {
+    t |> run("an ultravox mmproj arms a stock decoder's audio: bare rows after the text (needs Llama-3.2-1B + the ultravox mmproj)") @(t : T?) {
+        if (!jit_enabled()) {
+            t |> skip("interpreted (dasLLAMA server tests are JIT-only)")
+            return
+        }
+        for (p in [UV_DEC_PATH, UV_MM_PATH, JFK_PATH]) {
+            if (!stat(p).is_valid) {
+                t |> skip("{base_name(p)} not present (set DASLLAMA_MODELS_DIR)")
+                return
+            }
+        }
+        let b64 = jfk_b64()
+        let text = "Transcribe this audio."
+        with_tower_audio_server(TOWER_PORT, true) $(base_url) {
+            GET("{base_url}/v1/stats") $(resp) {
+                var err : string
+                var js = read_json(string(resp.body), err)
+                t |> success(js != null && (js?["audio"] ?? false), "stats declares the audio arm")
+                t |> success(js != null && !(js?["vision"] ?? true), "and no vision arm: the file carries none")
+                if (js != null) {
+                    unsafe {
+                        delete js
+                    }
+                }
+            }
+            var plain = 0
+            POST("{base_url}/v1/chat/completions", "\{\"temperature\":0,\"messages\":[\{\"role\":\"user\",\"content\":\"{text}\"}]}") $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK))
+                plain = prompt_tokens_of(t, string(resp.body), "text alone")
+            }
+            let text_first = "\{\"temperature\":0,\"messages\":[\{\"role\":\"user\",\"content\":[\{\"type\":\"text\",\"text\":\"{text}\"},\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"{b64}\",\"format\":\"wav\"}}]}]}"
+            POST("{base_url}/v1/chat/completions", text_first) $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK))
+                t |> equal(prompt_tokens_of(t, string(resp.body), "text, then audio"), plain + UV_ROWS, "the clip adds its rows and no marker token")
+            }
+            POST("{base_url}/v1/chat/completions", audio_chat_body(b64, text)) $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK))
+                t |> equal(prompt_tokens_of(t, string(resp.body), "audio, then text"), plain + UV_ROWS, "the same count with the clip ahead of the text")
+            }
+            check_known_clip_reencoded(t, base_url, b64, text)
+            check_media_parts_limit(t, base_url)
+            check_assistant_media_dropped(t, base_url, text)
+        }
+    }
+}
+
+//! The clip is known, but no cached prefix runs under a new system line to its span: the probe sends it to the encoder
+//! before the submit, so one stream is admitted, carrying the clip's rows. Asked again, the cache holds the span.
+def private check_known_clip_reencoded(t : T?; base_url, b64, text : string) {
+    let sys_plain = text_prompt(t, base_url, SYS_A, text)
+    let moved = ask_counted(t, base_url, SYS_A, b64, text, "a known clip under a new system line")
+    t |> equal(moved.reply.prompt, sys_plain + UV_ROWS, "the clip adds its rows under the new system line")
+    t |> equal(moved.admitted, 1l, "one stream admitted: the uncovered span was encoded before the submit")
+    t |> equal(moved.rows, int64(UV_ROWS), "and it brought the clip's rows")
+    t |> success(moved.reply.finish != "media_lost", "the reply finishes '{moved.reply.finish}'")
+    let again = ask_counted(t, base_url, SYS_A, b64, text, "the same ask again")
+    t |> equal(again.admitted, 1l, "one stream admitted")
+    t |> equal(again.rows, 0l, "the cached span brings no rows")
+    t |> equal(again.reply.prompt, moved.reply.prompt, "the same prompt")
+}
+
+//! A request's media parts are capped: one past the limit is refused by name before any part decodes; at the limit
+//! the parts decode, and the first one's bad base64 answers.
+def private check_media_parts_limit(t : T?; base_url : string) {
+    for (n in [MEDIA_SPANS_LIMIT, MEDIA_SPANS_LIMIT + 1]) {
+        let parts = join([for (_i in range(n)); "\{\"type\":\"input_audio\",\"input_audio\":\{\"data\":\"!!!not-base64!!!\",\"format\":\"wav\"}}"], ",")
+        POST("{base_url}/v1/chat/completions", "\{\"messages\":[\{\"role\":\"user\",\"content\":[{parts}]}]}") $(resp) {
+            let body = string(resp.body)
+            t |> equal(int(resp.status_code), int(http_status.BAD_REQUEST), "{n} parts: {body}")
+            let names_limit = find(body, "carries {n} media parts; the limit is {MEDIA_SPANS_LIMIT}") >= 0
+            if (n > MEDIA_SPANS_LIMIT) {
+                t |> success(names_limit, "{n} parts: the 400 names the limit ({body})")
+            } else {
+                t |> success(!names_limit && find(body, "not valid base64") >= 0, "{n} parts are within the limit ({body})")
+            }
+        }
+    }
+}
+
+//! Media rides user messages: an image on an assistant turn - this slot has no vision arm - is dropped, and the
+//! request answers as its text alone.
+def private check_assistant_media_dropped(t : T?; base_url, text : string) {
+    let turns_head = "\{\"temperature\":0,\"messages\":[\{\"role\":\"user\",\"content\":\"Hi.\"},\{\"role\":\"assistant\",\"content\":["
+    let turns_tail = "\{\"type\":\"text\",\"text\":\"Hello.\"}]},\{\"role\":\"user\",\"content\":\"{text}\"}]}"
+    var text_turns = 0
+    POST("{base_url}/v1/chat/completions", "{turns_head}{turns_tail}") $(resp) {
+        t |> equal(int(resp.status_code), int(http_status.OK))
+        text_turns = prompt_tokens_of(t, string(resp.body), "the turns as text")
+    }
+    POST("{base_url}/v1/chat/completions", "{turns_head}\{\"type\":\"image_url\",\"image_url\":\{\"url\":\"data:image/png;base64,AAAA\"}},{turns_tail}") $(resp) {
+        t |> equal(int(resp.status_code), int(http_status.OK), "an assistant turn's image is no vision request: {resp.body}")
+        t |> equal(prompt_tokens_of(t, string(resp.body), "an image on the assistant turn"), text_turns, "and the prompt is the text turns alone")
+    }
+}
+
+let SYS_A = "You are a careful listener."
+let SYS_B = "You answer in one short sentence."
+let SYS_C = "You are brief."
+
+// A known clip under a system line the prefix cache holds no span for, sent to the scheduler rowless: the stream finishes
+// `media_lost` on admission, and the server encodes the clip and submits once more - the client sees one answer.
+let LOST_PORT = 18178
+
+[test]
+def test_openai_server_audio_lost_span(t : T?) {
+    t |> run("a span the cache does not hold is encoded and resubmitted (needs Llama-3.2-1B + the ultravox mmproj)") @(t : T?) {
+        var inscope files <- [UV_DEC_PATH, UV_MM_PATH, JFK_PATH]
+        return if (model_missing(t, files))
+        let b64 = jfk_b64()
+        let text = "Transcribe this audio."
+        with_tower_audio_server(LOST_PORT, false) $(base_url) {
+            let cold = ask_counted(t, base_url, SYS_A, b64, text, "the clip, new to the slot")
+            t |> equal(cold.admitted, 1l, "a new clip encodes before the submit: one stream")
+            t |> equal(cold.rows, int64(UV_ROWS), "carrying the clip's rows")
+            let held = ask_counted(t, base_url, SYS_A, b64, text, "the same ask: the cache holds the span")
+            t |> equal(held.admitted, 1l, "a span the cache holds is admitted once")
+            t |> equal(held.rows, 0l, "with no rows")
+            let lost = ask_counted(t, base_url, SYS_B, b64, text, "the clip under a new system line")
+            t |> success(lost.reply.finish != "media_lost" && !empty(lost.reply.finish), "the reply finishes '{lost.reply.finish}', never media_lost")
+            t |> success(!empty(lost.reply.content), "and answers")
+            t |> equal(lost.admitted, 2l, "two streams admitted: the rowless one lost its span, the resubmission carried the rows")
+            t |> equal(lost.rows, int64(UV_ROWS), "the resubmission brought the clip's rows")
+            let sys_plain = text_prompt(t, base_url, SYS_B, text)
+            t |> equal(lost.reply.prompt, sys_plain + UV_ROWS, "the prompt a cold ask of the clip takes")
+            // streamed, the retry is invisible on the wire: one opening role delta, one finish, one [DONE]
+            let before = stats_counts(t, base_url)
+            POST("{base_url}/v1/chat/completions", system_chat_body(SYS_C, b64, text, true)) $(resp) {
+                let body = string(resp.body)
+                t |> equal(int(resp.status_code), int(http_status.OK))
+                t |> equal(count(body, "\"role\":\"assistant\""), 1, "one role delta across the retry: {body}")
+                t |> equal(count(body, "[DONE]"), 1, "one [DONE]")
+                t |> equal(count(body, "media_lost"), 0, "no media_lost on the wire")
+                t |> success(count(body, "\"finish_reason\":\"stop\"") + count(body, "\"finish_reason\":\"length\"") == 1, "one finish chunk")
+            }
+            t |> equal(stats_counts(t, base_url).admitted - before.admitted, 2l, "the streamed ask took the retry too")
+        }
+    }
+}
+
+// POST /v1/models/load arms a runtime-loaded slot's audio from the body's `audio_mmproj`; a file that arms nothing serves
+// the model as text and says why in `tower_note`.
+let LOAD_PORT = 18183
+let SMOL_PATH = path_join(models_dir(), "SmolLM2-135M-Instruct-Q8_0.gguf")
+
+def private with_text_server(port : int; blk : block<(base_url : string) : void>) {
+    with_job_status(1) $(finished) {
+        new_thread() @() {
+            allow_cpu_prefill()
+            var m <- load_model(SMOL_PATH, QuantMode.q8)
+            set_model(m, "test-smol")
+            set_default_max_tokens(16l)
+            run_server(port)
+            finished |> notify_and_release
+        }
+        let ready = serve_clients(port, 1200, "/v1/models", blk)
+        finished |> join
+        assert(ready, "dasllama text server became ready")
+    }
+}
+
+//! /v1/stats' default-slot audio arm, and the arm of the slot named `id`
+def private audio_arms(t : T?; base_url, id : string) : tuple<default_arm : bool; slot_arm : bool> {
+    var res = (default_arm = false, slot_arm = false)
+    GET("{base_url}/v1/stats") $(resp) {
+        var err : string
+        var js = read_json(string(resp.body), err)
+        t |> success(js != null, "stats JSON parses")
+        if (js != null) {
+            res.default_arm = js?["audio"] ?? false
+            for (mv in js?["models"].value as _array) {
+                if ((mv?["name"] ?? "") == id) {
+                    res.slot_arm = mv?["audio"] ?? false
+                }
+            }
+            unsafe {
+                delete js
+            }
+        }
+    }
+    return res
+}
+
+[test]
+def test_openai_server_audio_runtime_load(t : T?) {
+    t |> run("a runtime load arms audio from audio_mmproj (needs SmolLM2-135M, Llama-3.2-1B + the ultravox mmproj)") @(t : T?) {
+        var inscope files <- [SMOL_PATH, UV_DEC_PATH, UV_MM_PATH, JFK_PATH]
+        return if (model_missing(t, files))
+        let dec = to_generic_path(UV_DEC_PATH)
+        let missing = to_generic_path(path_join(test_temp_dir(), "no-such-mmproj.gguf"))
+        with_text_server(LOAD_PORT) $(base_url) {
+            t |> success(!audio_arms(t, base_url, "test-smol").default_arm, "the boot slot has no audio arm")
+            POST("{base_url}/v1/models/load", "\{\"path\":\"{dec}\",\"id\":\"uv-bad\",\"ctx\":2048,\"activate\":false,\"audio_mmproj\":\"{missing}\"}") $(resp) {
+                let body = string(resp.body)
+                t |> equal(int(resp.status_code), int(http_status.OK), "the model serves without the arm: {body}")
+                var err : string
+                var js = read_json(body, err)
+                t |> success(!empty(js?["tower_note"] ?? ""), "and tower_note says why: {body}")
+                unsafe {
+                    delete js
+                }
+            }
+            t |> success(!audio_arms(t, base_url, "uv-bad").slot_arm, "the slot a missing mmproj names has no audio arm")
+            POST("{base_url}/v1/models/unload", "\{\"model\":\"uv-bad\"}") $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK))
+            }
+            POST("{base_url}/v1/models/load", "\{\"path\":\"{dec}\",\"id\":\"uv-live\",\"ctx\":2048,\"audio_mmproj\":\"{to_generic_path(UV_MM_PATH)}\"}") $(resp) {
+                let body = string(resp.body)
+                t |> equal(int(resp.status_code), int(http_status.OK), body)
+                var err : string
+                var js = read_json(body, err)
+                t |> equal(js?["tower_note"] ?? "?", "", "the arm took: {body}")
+                unsafe {
+                    delete js
+                }
+            }
+            let arms = audio_arms(t, base_url, "uv-live")
+            t |> success(arms.slot_arm, "the loaded slot declares the audio arm")
+            t |> success(arms.default_arm, "and, made the default, so does the server")
+            POST("{base_url}/v1/chat/completions", audio_chat_body(jfk_b64(), "Transcribe this audio.")) $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK), "the armed slot takes input_audio: {resp.body}")
+                t |> success(prompt_tokens_of(t, string(resp.body), "the clip on the runtime-armed slot") > UV_ROWS, "the clip's rows are in the prompt")
+            }
+        }
+    }
+}
diff --git a/utils/dasllama-server/test_openai_server_speech_multi.das b/utils/dasllama-server/test_openai_server_speech_multi.das
index 9c805dd00e..4dc654ace8 100644
--- a/utils/dasllama-server/test_openai_server_speech_multi.das
+++ b/utils/dasllama-server/test_openai_server_speech_multi.das
@@ -5,6 +5,7 @@ options stack = 524288   // every dasLLAMA program root takes this budget (optio
 require dastest/testing_boost public
 require openai_server                                   // add_asr_model / add_tts_model / run_server (sibling)
 require _server_rig                                     // models_dir (sibling)
+require dasllama/dasllama                               // set_metal_mode: the mode the ASR workers' decoder takes
 require openai/openai_audio                             // transcribe / speech: the two speech requests
 require dashv/dashv_boost                               // GET / POST: the readiness poll, /v1/models, the shutdown
 require daslib/jobque_boost                             // with_job_status / new_thread: the server thread, the four clients at once
@@ -21,7 +22,7 @@ require daslib/strings_boost   // count
 // Model-gated (Qwen3-ASR 0.6B and 1.7B with their mmprojs, kitten-nano with the front-end packs,
 // pocket-tts-en-q8) and JIT-only; skips cleanly otherwise.
 
-let TEST_PORT = 18170   // 18170, 18173, 18174: this file's three boots; 18097-18163 belong to the sibling suites
+let TEST_PORT = 18170   // 18170, 18173 .. 18176: this file's five boots; 18097-18163 belong to the sibling suites
 
 let ASR_A = "Qwen3-ASR-0.6B-Q8_0"
 let ASR_B = "Qwen3-ASR-1.7B-Q8_0"
@@ -202,6 +203,52 @@ def test_one_asr_model_takes_any_name(t : T?) {
     }
 }
 
+//! where /v1/stats says the one ASR model of an ASR-only boot decodes, "" when the boot never served or answered no clip
+def private asr_alone_decoder(t : T?; port : int; mode : MetalMode) : string {
+    var decoder = ""
+    with_job_status(1) $(finished) {
+        new_thread() <| @capture(= finished, = port, = mode) {
+            set_metal_mode(mode)   // the engine's mode: the workers take it for a decoder that is a Model session
+            add_asr_model(path_join(models_dir(), "{ASR_A}.gguf"), asr_mmproj(ASR_A))
+            run_server(port)   // blocks until POST /shutdown
+            finished |> notify_and_release
+        }
+        let ready = serve_clients(port, 1200, "/v1/models") $(base_url) {
+            let res = transcribe(openai_client("{base_url}/v1"), ASR_A, JFK_PATH)
+            t |> success(res.ok && heard_jfk(res.text), "{mode}: {res.text}{res.error.message}")
+            GET("{base_url}/v1/stats") $(resp) {
+                var err = ""
+                var js = read_json(resp != null ? string(resp.body) : "", err)
+                t |> equal(js?["asr_ready"] ?? 0, 1, "the stats of a boot with no LLM count its ASR worker")
+                t |> equal(js?["asr_done_jobs"] ?? 0, 1, "and the clip it read")
+                if (res.ok) {
+                    decoder = js?["asr"]?["models"]?[0]?["decoder"] ?? ""
+                }
+                unsafe {
+                    delete js
+                }
+            }
+        }
+        finished |> join
+        t |> success(ready, "a boot with an ASR model and nothing else serves")
+    }
+    return decoder
+}
+
+//! An ASR model serves with no LLM and no TTS beside it, and its decoder runs where the engine's Metal mode puts it:
+//! on the device under the mode a Metal build serves with, on the CPU with the mode off.
+[test]
+def test_asr_alone_serves_on_the_engine_backend(t : T?) {
+    var inscope files <- [path_join(models_dir(), "{ASR_A}.gguf"), asr_mmproj(ASR_A)]
+    return if (model_missing(t, files))
+    t |> equal(asr_alone_decoder(t, TEST_PORT + 5, MetalMode.off), "cpu")
+    if (!has_prefill_override("metal")) {
+        t |> skip("no Metal driver in this build: the device half needs one")
+        return
+    }
+    t |> equal(asr_alone_decoder(t, TEST_PORT + 6, MetalMode.when_available), "metal")
+}
+
 //! An ASR model that cannot load fails the boot with the loader's reason: the speech thread reports it to the engine,
 //! which was waiting on that thread's first word. The control is the return itself - a boot that hung never gets here.
 [test]
diff --git a/utils/dasllama-server/test_openai_server_stream.das b/utils/dasllama-server/test_openai_server_stream.das
index 42eabed52a..b74ad5f776 100644
--- a/utils/dasllama-server/test_openai_server_stream.das
+++ b/utils/dasllama-server/test_openai_server_stream.das
@@ -335,10 +335,11 @@ def test_openai_server_stream(t : T?) {   // nolint:STYLE038 — one live server
                 t |> equal(int(resp.status_code), int(http_status.OK))
             }
         }
-        t |> run("prefix cache: the same request twice returns the identical completion, warm run cached") @(t : T?) {
-            // The rendered prompt must span at least one full page (server default P = 64 = the
-            // prefill chunk, so warm chunk boundaries align with cold's and flash prefill repeats
-            // the exact same evals — greedy output is bit-identical, not just similar).
+        t |> run("prefix cache: a request served off the cache repeats itself token for token, warm run cached") @(t : T?) {
+            // The rendered prompt spans whole pages (server default P = 64). The cold run prefills the prompt as a
+            // batch; a cached run attaches every row but the last token's and evals that one alone, and a row
+            // evaled alone and in a batch differ in rounding - so the two cached runs must agree token for token,
+            // and the cold run need not match them (followup_general.md row 212).
             let user = ("Tell me about a little robot who lives in a small village near the mountains" +
                 " and spends every evening counting the birds that cross the sky above the old bakery" +
                 " while dreaming about the day it will finally learn to fly like them." +
@@ -348,7 +349,7 @@ def test_openai_server_stream(t : T?) {   // nolint:STYLE038 — one live server
                 " whether the mountains are lonely too. Please tell the story slowly and gently.")
             let body = "\{\"messages\":[\{\"role\":\"user\",\"content\":\"{user}\"}],\"max_tokens\":24}"
             var replies : array<string>
-            for (_round in range(2)) {
+            for (_round in range(3)) {
                 POST("{base_url}/v1/chat/completions", body) $(resp) {
                     t |> equal(int(resp.status_code), int(http_status.OK))
                     var perr = ""
@@ -364,10 +365,11 @@ def test_openai_server_stream(t : T?) {   // nolint:STYLE038 — one live server
                     }
                 }
             }
-            t |> equal(2, length(replies))
-            if (length(replies) == 2) {
+            t |> equal(3, length(replies))
+            if (length(replies) == 3) {
                 t |> success(!empty(replies[0]), "cold reply non-empty")
-                t |> equal(replies[0], replies[1])
+                t |> success(!empty(replies[1]), "cached reply non-empty")
+                t |> equal(replies[1], replies[2])
             }
             GET("{base_url}/v1/stats") $(resp) {
                 var perr = ""
diff --git a/utils/dasllama-server/test_server_flags.das b/utils/dasllama-server/test_server_flags.das
index e022227254..e9c106c73b 100644
--- a/utils/dasllama-server/test_server_flags.das
+++ b/utils/dasllama-server/test_server_flags.das
@@ -214,6 +214,40 @@ def test_speech_roster_from_toml(t : T?) {
     remove(path)
 }
 
+//! The audio tower's two spellings: `--audio-mmproj` on the command line and `audio_mmproj` in the config, the flag
+//! winning over a config that is not authoritative.
+[test]
+def test_audio_mmproj_flag_and_key(t : T?) {
+    t |> run("--audio-mmproj parses onto the server's arguments") @(t : T?) {
+        let r <- parse_args(type<ServerArgs>, ["--audio-mmproj", "au.gguf", "--image-mmproj", "v.gguf"])
+        t |> success(r |> is_ok, "the flags parse")
+        if (r |> is_ok) {
+            let cfg = r |> unwrap
+            t |> equal(cfg.audio_mmproj, "au.gguf")
+            t |> equal(cfg.image_mmproj, "v.gguf", "and stays apart from the vision flag")
+        }
+    }
+    let path = path_join(test_temp_dir(), "audio_mmproj.toml")
+    t |> run("the config's audio_mmproj lands, under a flag only when the config is authoritative") @(t : T?) {
+        t |> success(fwrite(path, "audio_mmproj = \"toml.gguf\"\n"), "wrote the config")
+        var plain = ServerArgs(config = path)
+        t |> success(apply_config(plain), "the config reads")
+        t |> equal(plain.audio_mmproj, "toml.gguf", "no flag: the key is the arm")
+        var flagged = ServerArgs(config = path, audio_mmproj = "cli.gguf")
+        set_cli_source("audio_mmproj", true)
+        t |> success(apply_config(flagged), "the config reads")
+        set_cli_source("audio_mmproj", false)
+        t |> equal(flagged.audio_mmproj, "cli.gguf", "the flag wins over a config that is not authoritative")
+        t |> success(fwrite(path, "authoritative = true\naudio_mmproj = \"toml.gguf\"\n"), "wrote the authoritative config")
+        var saved = ServerArgs(config = path, audio_mmproj = "cli.gguf")
+        set_cli_source("audio_mmproj", true)
+        t |> success(apply_config(saved), "the authoritative config reads")
+        set_cli_source("audio_mmproj", false)
+        t |> equal(saved.audio_mmproj, "toml.gguf", "an authoritative config wins over the flag")
+    }
+    remove(path)
+}
+
 //! The roster a kind's flags make: the flat key's model first, with its own keys, then every other path named; a
 //! repeated flag's first value is the default, whatever clargs kept.
 [test]
diff --git a/utils/dasllama-server/tests/fixtures/config.json b/utils/dasllama-server/tests/fixtures/config.json
index 386c987019..9e940565c6 100644
--- a/utils/dasllama-server/tests/fixtures/config.json
+++ b/utils/dasllama-server/tests/fixtures/config.json
@@ -1 +1 @@
-{"surface":{"save_path": "D:/models/dasllama-server.toml", "sources": {"max_tokens": "toml", "gpu": "default", "lcpp_bin": "default", "mmproj": "default", "prefix": "default", "gpu_vram_mb": "default", "asr": "default", "tts_voices_dir": "default", "gpu_attn": "default", "flat": "default", "affinity": "cli", "gpu_stream": "default", "streams": "toml", "chunk_idle": "default", "rope_scaling": "default", "models_dir": "default", "gpu_dn": "default", "gpu_dense": "default", "port": "toml", "model": "toml", "asr_workers": "default", "chunk": "default", "yarn_orig_ctx": "default", "image_mmproj": "default", "models": "toml", "tts_lane": "default", "page_rows": "default", "gpu_layers": "default", "kv_dtype": "default", "quant": "default", "team_dispatch": "default", "threads": "default", "tts": "default", "rope_scale": "default", "metal": "default", "mtp": "default", "ctx": "default"}, "authoritative": false, "gpu_effective": "metal", "config": {"max_tokens": 64, "gpu": "", "lcpp_bin": "", "mmproj": "", "prefix": 0, "gpu_vram_mb": 0, "asr": "", "tts_voices_dir": "", "gpu_attn": false, "flat": false, "affinity": -1, "gpu_stream": 0, "streams": 4, "chunk_idle": 0, "rope_scaling": "", "models_dir": "", "gpu_dn": false, "gpu_dense": false, "port": 18132, "model": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "asr_workers": 1, "chunk": 512, "yarn_orig_ctx": 0, "image_mmproj": "", "tts_lane": "q8", "page_rows": 64, "gpu_layers": 0, "kv_dtype": "f16", "quant": "q8", "team_dispatch": "hybrid", "threads": 16, "tts": "", "rope_scale": 0, "metal": "off", "mtp": false, "ctx": 0}, "models": [{"path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "backend": "auto", "kv_dtype": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": true, "chunk_idle": -1, "streams": -1, "name": "smol", "prefix": -2, "page_rows": -1, "ctx": 0}, {"path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "backend": "cpu", "kv_dtype": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": false, "chunk_idle": -1, "streams": -1, "name": "tiny", "prefix": -2, "page_rows": -1, "ctx": 0}], "tts_models": [], "gpu_detected": "metal", "config_path": "D:/models/dasllama-server.toml", "asr_models": []},"status":{"model_files": [{"name": "tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "size": 1170781568, "kind": "gguf", "path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf"}, {"name": "SmolLM2-135M-Instruct-Q8_0.gguf", "size": 144811360, "kind": "gguf", "path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf"}, {"name": "kitten-nano.gguf", "size": 59331456, "kind": "gguf", "path": "D:/models/kitten-nano.gguf"}], "active_model": "SmolLM2-135M-Instruct-Q8_0.gguf", "dlim_rail": true, "metal": "when_available", "gpu": {"streamed_layers": 0, "backend": "", "resident_layers": 0, "vram_bytes": 0, "cls_resident": false, "dn_layers": 0, "reason": "no GPU tier installed", "dense_planes": 0, "attn_layers": 0, "supported": false}}}
\ No newline at end of file
+{"surface":{"save_path": "D:/models/dasllama-server.toml", "sources": {"max_tokens": "toml", "audio_mmproj": "default", "gpu": "default", "lcpp_bin": "default", "mmproj": "default", "prefix": "default", "gpu_vram_mb": "default", "asr": "default", "tts_voices_dir": "default", "gpu_attn": "default", "flat": "default", "affinity": "cli", "gpu_stream": "default", "streams": "toml", "chunk_idle": "default", "rope_scaling": "default", "models_dir": "default", "gpu_dn": "default", "gpu_dense": "default", "port": "toml", "model": "toml", "asr_workers": "default", "chunk": "default", "yarn_orig_ctx": "default", "image_mmproj": "default", "models": "toml", "tts_lane": "default", "page_rows": "default", "gpu_layers": "default", "kv_dtype": "default", "quant": "default", "team_dispatch": "default", "threads": "default", "tts": "default", "rope_scale": "default", "metal": "default", "mtp": "default", "ctx": "default"}, "authoritative": false, "gpu_effective": "metal", "config": {"max_tokens": 64, "audio_mmproj": "", "gpu": "", "lcpp_bin": "", "mmproj": "", "prefix": 0, "gpu_vram_mb": 0, "asr": "", "tts_voices_dir": "", "gpu_attn": false, "flat": false, "affinity": -1, "gpu_stream": 0, "streams": 4, "chunk_idle": 0, "rope_scaling": "", "models_dir": "", "gpu_dn": false, "gpu_dense": false, "port": 18132, "model": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "asr_workers": 1, "chunk": 512, "yarn_orig_ctx": 0, "image_mmproj": "", "tts_lane": "q8", "page_rows": 64, "gpu_layers": 0, "kv_dtype": "f16", "quant": "q8", "team_dispatch": "hybrid", "threads": 16, "tts": "", "rope_scale": 0, "metal": "off", "mtp": false, "ctx": 0}, "models": [{"path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "backend": "auto", "kv_dtype": "", "audio_mmproj": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": true, "chunk_idle": -1, "streams": -1, "name": "smol", "prefix": -2, "page_rows": -1, "ctx": 0}, {"path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "backend": "cpu", "kv_dtype": "", "audio_mmproj": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": false, "chunk_idle": -1, "streams": -1, "name": "tiny", "prefix": -2, "page_rows": -1, "ctx": 0}], "tts_models": [], "gpu_detected": "metal", "config_path": "D:/models/dasllama-server.toml", "asr_models": []},"status":{"model_files": [{"name": "tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "size": 1170781568, "kind": "gguf", "path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf"}, {"name": "SmolLM2-135M-Instruct-Q8_0.gguf", "size": 144811360, "kind": "gguf", "path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf"}, {"name": "kitten-nano.gguf", "size": 59331456, "kind": "gguf", "path": "D:/models/kitten-nano.gguf"}], "active_model": "SmolLM2-135M-Instruct-Q8_0.gguf", "dlim_rail": true, "metal": "when_available", "gpu": {"streamed_layers": 0, "backend": "", "resident_layers": 0, "vram_bytes": 0, "cls_resident": false, "dn_layers": 0, "reason": "no GPU tier installed", "dense_planes": 0, "attn_layers": 0, "supported": false}}}
\ No newline at end of file
diff --git a/utils/dasllama-server/tests/fixtures/config_tts.json b/utils/dasllama-server/tests/fixtures/config_tts.json
index 98260e66cf..e5650ccc4d 100644
--- a/utils/dasllama-server/tests/fixtures/config_tts.json
+++ b/utils/dasllama-server/tests/fixtures/config_tts.json
@@ -1 +1 @@
-{"surface":{"save_path": "D:/models/dasllama-server.toml", "sources": {"max_tokens": "toml", "gpu": "default", "lcpp_bin": "default", "mmproj": "default", "prefix": "default", "gpu_vram_mb": "default", "asr": "default", "tts_voices_dir": "default", "gpu_attn": "default", "flat": "default", "affinity": "cli", "gpu_stream": "default", "streams": "toml", "chunk_idle": "default", "rope_scaling": "default", "models_dir": "default", "gpu_dn": "default", "gpu_dense": "default", "port": "toml", "model": "toml", "asr_workers": "default", "chunk": "default", "yarn_orig_ctx": "default", "image_mmproj": "default", "models": "toml", "tts_lane": "default", "page_rows": "default", "gpu_layers": "default", "kv_dtype": "default", "quant": "default", "team_dispatch": "default", "threads": "default", "tts": "cli", "rope_scale": "default", "metal": "default", "mtp": "default", "ctx": "default"}, "authoritative": false, "gpu_effective": "metal", "config": {"max_tokens": 64, "gpu": "", "lcpp_bin": "", "mmproj": "", "prefix": 0, "gpu_vram_mb": 0, "asr": "", "tts_voices_dir": "", "gpu_attn": false, "flat": false, "affinity": -1, "gpu_stream": 0, "streams": 4, "chunk_idle": 0, "rope_scaling": "", "models_dir": "", "gpu_dn": false, "gpu_dense": false, "port": 18132, "model": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "asr_workers": 1, "chunk": 512, "yarn_orig_ctx": 0, "image_mmproj": "", "tts_lane": "q8", "page_rows": 64, "gpu_layers": 0, "kv_dtype": "f16", "quant": "q8", "team_dispatch": "hybrid", "threads": 16, "tts": "D:/models/kitten-nano.gguf", "rope_scale": 0, "metal": "off", "mtp": false, "ctx": 0}, "models": [{"path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "backend": "auto", "kv_dtype": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": true, "chunk_idle": -1, "streams": -1, "name": "smol", "prefix": -2, "page_rows": -1, "ctx": 0}, {"path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "backend": "cpu", "kv_dtype": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": false, "chunk_idle": -1, "streams": -1, "name": "tiny", "prefix": -2, "page_rows": -1, "ctx": 0}], "tts_models": [{"id": "", "path": "D:/models/kitten-nano.gguf", "lane": "q8", "voices_dir": ""}], "gpu_detected": "metal", "config_path": "D:/models/dasllama-server.toml", "asr_models": []},"status":{"model_files": [{"name": "tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "size": 1170781568, "kind": "gguf", "path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf"}, {"name": "SmolLM2-135M-Instruct-Q8_0.gguf", "size": 144811360, "kind": "gguf", "path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf"}, {"name": "kitten-nano.gguf", "size": 59331456, "kind": "gguf", "path": "D:/models/kitten-nano.gguf"}], "active_model": "SmolLM2-135M-Instruct-Q8_0.gguf", "dlim_rail": true, "metal": "when_available", "gpu": {"streamed_layers": 0, "backend": "", "resident_layers": 0, "vram_bytes": 0, "cls_resident": false, "dn_layers": 0, "reason": "no GPU tier installed", "dense_planes": 0, "attn_layers": 0, "supported": false}}}
\ No newline at end of file
+{"surface":{"save_path": "D:/models/dasllama-server.toml", "sources": {"max_tokens": "toml", "audio_mmproj": "default", "gpu": "default", "lcpp_bin": "default", "mmproj": "default", "prefix": "default", "gpu_vram_mb": "default", "asr": "default", "tts_voices_dir": "default", "gpu_attn": "default", "flat": "default", "affinity": "cli", "gpu_stream": "default", "streams": "toml", "chunk_idle": "default", "rope_scaling": "default", "models_dir": "default", "gpu_dn": "default", "gpu_dense": "default", "port": "toml", "model": "toml", "asr_workers": "default", "chunk": "default", "yarn_orig_ctx": "default", "image_mmproj": "default", "models": "toml", "tts_lane": "default", "page_rows": "default", "gpu_layers": "default", "kv_dtype": "default", "quant": "default", "team_dispatch": "default", "threads": "default", "tts": "cli", "rope_scale": "default", "metal": "default", "mtp": "default", "ctx": "default"}, "authoritative": false, "gpu_effective": "metal", "config": {"max_tokens": 64, "audio_mmproj": "", "gpu": "", "lcpp_bin": "", "mmproj": "", "prefix": 0, "gpu_vram_mb": 0, "asr": "", "tts_voices_dir": "", "gpu_attn": false, "flat": false, "affinity": -1, "gpu_stream": 0, "streams": 4, "chunk_idle": 0, "rope_scaling": "", "models_dir": "", "gpu_dn": false, "gpu_dense": false, "port": 18132, "model": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "asr_workers": 1, "chunk": 512, "yarn_orig_ctx": 0, "image_mmproj": "", "tts_lane": "q8", "page_rows": 64, "gpu_layers": 0, "kv_dtype": "f16", "quant": "q8", "team_dispatch": "hybrid", "threads": 16, "tts": "D:/models/kitten-nano.gguf", "rope_scale": 0, "metal": "off", "mtp": false, "ctx": 0}, "models": [{"path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf", "backend": "auto", "kv_dtype": "", "audio_mmproj": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": true, "chunk_idle": -1, "streams": -1, "name": "smol", "prefix": -2, "page_rows": -1, "ctx": 0}, {"path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "backend": "cpu", "kv_dtype": "", "audio_mmproj": "", "quant": "", "chunk": -1, "image_mmproj": "", "default": false, "chunk_idle": -1, "streams": -1, "name": "tiny", "prefix": -2, "page_rows": -1, "ctx": 0}], "tts_models": [{"id": "", "path": "D:/models/kitten-nano.gguf", "lane": "q8", "voices_dir": ""}], "gpu_detected": "metal", "config_path": "D:/models/dasllama-server.toml", "asr_models": []},"status":{"model_files": [{"name": "tinyllama-1.1b-chat-v1.0.Q8_0.gguf", "size": 1170781568, "kind": "gguf", "path": "D:/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf"}, {"name": "SmolLM2-135M-Instruct-Q8_0.gguf", "size": 144811360, "kind": "gguf", "path": "D:/models/SmolLM2-135M-Instruct-Q8_0.gguf"}, {"name": "kitten-nano.gguf", "size": 59331456, "kind": "gguf", "path": "D:/models/kitten-nano.gguf"}], "active_model": "SmolLM2-135M-Instruct-Q8_0.gguf", "dlim_rail": true, "metal": "when_available", "gpu": {"streamed_layers": 0, "backend": "", "resident_layers": 0, "vram_bytes": 0, "cls_resident": false, "dn_layers": 0, "reason": "no GPU tier installed", "dense_planes": 0, "attn_layers": 0, "supported": false}}}
\ No newline at end of file