From 79e0f449f144c43e9c5701e44d723b118513bb9b Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 14:07:40 -0700
Subject: [PATCH 01/30] =?UTF-8?q?llvm=20-exe:=20actually=20print=20the=20e?=
 =?UTF-8?q?xception=20=E2=80=94=20jit=5Frun=5Fmain=5Fguarded=20never=20flu?=
 =?UTF-8?q?shed=20its=20printer?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Copilot caught this on #3581 after it merged. jit_run_main_guarded built a TextPrinter and streamed
"EXCEPTION: <msg>" into it, then returned without calling output(). TextWriter's destructor only
frees largeBuffer; TextPrinter::output() is the sole thing in the class that printf+fflush's. So the
print half of e2b818643 was dead code: a standalone -exe panic set the right exit status and said
nothing.

Why e2b818643's own check missed it: it validated by observation and shipped no fixture, so nothing
automated ever asserted the text. The exit code was correct throughout, which is the half that was
easy to see.

Proven on this build, not argued: a `panic("boom from the exe entry")` fixture compiled with
-jit -exe and run beside its runtime DLLs now prints

    EXCEPTION: boom from the exe entry

and exits 1. The message is verbatim the literal in this function, which is what attributes the
output to this line rather than to some other path on the panic rail.

Still missing, and named here so it is not lost again: a regression test. An -exe fixture in CI is
awkward (it needs the JIT plus a working linker, and clang-cl link discovery is already flaky on
Windows locally), so the honest home for this is a tests-cpp case driving jit_run_main_guarded with
a panicking context and capturing stdout.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019ruKZPG8G7SPEUyZtvBzcT
---
 src/builtin/module_jit.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/builtin/module_jit.cpp b/src/builtin/module_jit.cpp
index 9615d7df2c..64856ecd31 100644
--- a/src/builtin/module_jit.cpp
+++ b/src/builtin/module_jit.cpp
@@ -1653,6 +1653,7 @@ DAS_API int32_t jit_run_main_guarded ( das::Context * ctx, void * mainFn, int32_
     if ( !ok ) {
         das::TextPrinter tp;
         tp << "EXCEPTION: " << (ctx->getException() ? ctx->getException() : "unknown") << "\n";
+        tp.output();    // TextWriter's dtor only frees its buffer — output() is what prints
         return 1;
     }
     return rc;

From 8cb3a8b4f8fa3db24dd2887f8a7344628561f3ac Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 19:02:04 -0700
Subject: [PATCH 02/30] dasllama-convert + fio direct writer: GLM conversion
 383s -> 145s, peak commit 150 -> 82 GB
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three pieces, measured on GLM-4.5-Air Q4_K_M (78.6 GB image):

- fio dwrite_* — cache-bypassing strictly-ascending sequential writer
  (open/append/band/commit/stat/close). Win32: FILE_FLAG_NO_BUFFERING +
  preallocate (ascending writes keep NTFS VDL zero-fill off the bill);
  POSIX: fallocate + fadvise(DONTNEED); macOS: F_NOCACHE + F_PREALLOCATE.
  The handle owns a sector-aligned bounce band, so callers append any
  pointer at any size; dwrite_band/commit hand the band out for
  zero-copy producers; dwrite_stat splits stage vs syscall time.
  save_image rides it: buffered long_fwrite was worth 275 MB/s on big
  images, the direct writer sustains 1664-1720 MB/s per plane (rested-
  drive GLM aggregate 760 MB/s; per-plane MB/s now logged >= 256 MB).
  Meta serializes first so the exact file size preallocates up front;
  the header patches through a normal handle after close.

- win32 mmap shim: PAGE_WRITECOPY -> PAGE_READONLY. Copy-on-write
  sections charge commit for every page that COULD be privatized, so a
  73 GB gguf mapping billed 73 GB of private bytes on top of the model
  (measured 149.9 GB peak for the GLM conversion; 81.9 GB after). Now
  matches POSIX PROT_READ and faults loudly on an accidental write.

- utils/dasllama-convert — offline GGUF -> .dlim (clargs; -m/-o/-q/
  -f planar|metal|vulkan/--force/--keep-stale-tmp). Emits the identity-
  hashed name the load path looks for, and sweeps stale
  *.dlim.<ticks>.tmp siblings by default (killed runs leave full-size
  ones; 177.5 GB of them found on this box).

Output verified byte-identical (SHA256) to the previous writer at
2.4 GB and 82 GB; the load path maps the tool's image directly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 include/daScript/simulate/aot_builtin_fio.h  |   6 +
 modules/dasLLAMA/dasllama/dasllama_image.das | 216 +++++++---
 src/builtin/module_builtin_fio.cpp           | 402 ++++++++++++++++++-
 utils/dasllama-convert/main.das              | 180 +++++++++
 4 files changed, 737 insertions(+), 67 deletions(-)
 create mode 100644 utils/dasllama-convert/main.das

diff --git a/include/daScript/simulate/aot_builtin_fio.h b/include/daScript/simulate/aot_builtin_fio.h
index 34bac16a69..acc7570cc1 100644
--- a/include/daScript/simulate/aot_builtin_fio.h
+++ b/include/daScript/simulate/aot_builtin_fio.h
@@ -89,6 +89,12 @@ namespace das {
     DAS_API void builtin_map_file ( const FILE* _f, const TBlock<void, TTemporary<TArray<uint8_t>>>& blk, Context*, LineInfoArg * at );
     DAS_API void * builtin_fmap_open ( const char * name, uint64_t * size, Context * context, LineInfoArg * at );
     DAS_API void builtin_fmap_close ( void * data, uint64_t size, Context * context, LineInfoArg * at );
+    DAS_API void * builtin_dwrite_open ( const char * name, uint64_t total_bytes, uint64_t band_bytes, Context * context, LineInfoArg * at );
+    DAS_API bool builtin_dwrite_append ( void * h, void * data, uint64_t bytes, Context * context, LineInfoArg * at );
+    DAS_API void * builtin_dwrite_band ( void * h, uint64_t * avail, Context * context, LineInfoArg * at );
+    DAS_API bool builtin_dwrite_commit ( void * h, uint64_t bytes, Context * context, LineInfoArg * at );
+    DAS_API uint64_t builtin_dwrite_stat ( void * h, int32_t which, Context * context, LineInfoArg * at );
+    DAS_API bool builtin_dwrite_close ( void * h, Context * context, LineInfoArg * at );
     DAS_API char * builtin_dirname ( const char * name, Context * context, LineInfoArg * at );
     DAS_API char * builtin_basename ( const char * name, Context * context, LineInfoArg * at );
     DAS_API bool builtin_fstat ( const FILE * f, FStat & fs, Context * context, LineInfoArg * at );
diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index 6c0076b519..3789d2ec6c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -72,16 +72,84 @@ def private pad_to_page(cur : uint64) : uint64 {
     return (cur + page - 1ul) / page * page
 }
 
-def private write_zeros(f : file; n : uint64) {
-    if (n == 0ul) {
+let private IMAGE_WRITE_BAND = 16l * 1024l * 1024l   // the direct writer's staging band
+let private SECTION_TABLE_SLACK = 65536ul            // preallocation headroom for the section blob
+
+// The image's byte sink: append-only and strictly ascending, which is what keeps NTFS from
+// charging valid-data-length zero-fill on the preallocated file (measured: 3.4 s per 8 GB gap).
+struct private ImgWriter {
+    h : void? = null
+    cur : uint64 = 0ul
+    ok : bool = true
+}
+
+def private w_open(path : string; total : uint64) : ImgWriter {
+    let h = unsafe(dwrite_open(path, total, uint64(IMAGE_WRITE_BAND)))
+    return ImgWriter(h = h, ok = h != null)
+}
+
+def private w_append(var w : ImgWriter; p : void?; nbytes : uint64) {
+    if (!w.ok || nbytes == 0ul) {
+        return
+    }
+    if (!unsafe(dwrite_append(w.h, p, nbytes))) {
+        w.ok = false   // a dead save stays dead — don't keep pushing bytes at a full disk
+        return
+    }
+    w.cur += nbytes
+}
+
+def private w_zeros(var w : ImgWriter; n : uint64) {
+    if (n == 0ul || !w.ok) {
         return
     }
     var z : array<uint8>
     z |> resize(int(n))
-    f |> fwrite(z)
+    unsafe {
+        w_append(w, addr<void?>(z[0]), n)
+    }
     delete z
 }
 
+def private w_close(var w : ImgWriter) : bool {
+    if (w.h == null) {
+        return false
+    }
+    let flushed = unsafe(dwrite_close(w.h))
+    w.h = null
+    return flushed && w.ok
+}
+
+def private plane_end(cur : uint64; field : array<auto(TT)>) : uint64 {
+    if (empty(field)) {
+        return cur
+    }
+    return pad_to_page(cur) + uint64(long_length(field)) * uint64(typeinfo sizeof(field[0]))
+}
+
+// The image's final size, known before a byte goes out: planes contribute their sizes, the meta
+// blob is already serialized. The writer preallocates from this, so the file lands as one
+// contiguous run.
+def private image_total_bytes(var t; meta_bytes : uint64) : uint64 {
+    var cur = uint64(IMAGE_PAGE)
+    apply(t) $ [unused_argument(name)] (name : string; var field) {
+        static_if (typeinfo is_array(field)) {
+            static_if (!typeinfo is_string(field[0])) {
+                cur = plane_end(cur, field)
+            }
+        } static_elif (typeinfo safe_has_field < image_map > (field)) {
+            apply(field) $ [unused_argument(iname)] (iname : string; var ifield) {
+                static_if (typeinfo is_array(ifield)) {
+                    static_if (!typeinfo is_string(ifield[0])) {
+                        cur = plane_end(cur, ifield)
+                    }
+                }
+            }
+        }
+    }
+    return pad_to_page(cur + meta_bytes)
+}
+
 def private store_u32(var b : array<uint8>; at : int; v : uint) {
     unsafe {
         var p = unsafe(addr < uint? >(b[at]))
@@ -321,31 +389,33 @@ def private image_post_load(var t : Model) {
 
 // ===== save =====
 
-// one plane: pad to a page, bulk-write, account. long_ forms: a plane past 2 GiB
-// (voxtral-mini qblob = 3.6 G elements) does not fit the int32 length/byte-count rail
-def private write_plane(f : file; var sections : array<ImgSection>; var cur : uint64&;
-                        var ok : bool&; name : string; var field : array<auto(TT)>) {
-    if (empty(field) || !ok) {   // a dead save stays dead — don't keep pushing bytes at a full disk
+// one plane: pad to a page, bulk-append, account. The writer advances w.cur by exactly what it
+// accepted, so the section table cannot drift from the file. long_ forms: a plane past 2 GiB
+// (voxtral-mini qblob = 3.6 G elements) does not fit the int32 rail.
+def private write_plane(var w : ImgWriter; var sections : array<ImgSection>;
+                        name : string; var field : array<auto(TT)>) {
+    if (empty(field) || !w.ok) {
         return
     }
     let nbytes = uint64(long_length(field)) * uint64(typeinfo sizeof(field[0]))
-    let at = pad_to_page(cur)
-    write_zeros(f, at - cur)
-    let wrote = f |> long_fwrite(field)
-    if (uint64(wrote) != nbytes) {
-        // a short write is an I/O failure (ENOSPC in practice), not an accounting bug
-        to_log(LOG_ERROR, "dasLLAMA image: plane '{name}' short write {wrote} of {int64(nbytes)} bytes at offset {int64(at)} — disk full? image save aborted\n")
-        ok = false
+    let at = pad_to_page(w.cur)
+    w_zeros(w, at - w.cur)
+    let ts = ref_time_ticks()
+    unsafe {
+        w_append(w, addr<void?>(field[0]), nbytes)
+    }
+    // big planes get their own line: a uniform rate means the cost is systemic, a few slow ones
+    // mean stalls. Only >=256 MB, so small models stay quiet and this needs no env knob.
+    if (nbytes >= 256ul * 1024ul * 1024ul) {
+        let ms = int64(get_time_usec(ts)) / 1000l
+        let mb = int64(nbytes) >> 20l
+        to_log(LOG_INFO, "dasLLAMA image:   plane {name} {mb} MB in {ms} ms = {ms > 0l ? mb * 1000l / ms : 0l} MB/s\n")
+    }
+    if (!w.ok) {
+        to_log(LOG_ERROR, "dasLLAMA image: plane '{name}' failed writing {int64(nbytes)} bytes at offset {int64(at)} — disk full? image save aborted\n")
         return
     }
     sections |> push(ImgSection(name = name, off = at, bytes = nbytes))
-    cur = at + nbytes
-    // fwrite and the section table must agree byte-for-byte, or the mapped planes land at
-    // the wrong offsets — fail the save loudly, not the load
-    if (uint64(ftell(f)) != cur) {
-        to_log(LOG_ERROR, "dasLLAMA image: plane '{name}' wrote {ftell(f)} != accounted {int64(cur)} (nbytes {int64(nbytes)}) — image save aborted\n")
-        ok = false
-    }
 }
 
 //! Serialize a loaded weight-carrying struct as a prepared image: array planes page-aligned raw
@@ -355,27 +425,30 @@ def save_image(var t; path : string; tag : string = "") : bool {
     // per-writer tmp name: concurrent savers (parallel test workers on one cache miss) must
     // not clobber each other's half-written file; last atomic rename wins with same content
     let tmp_path = "{path}.{ref_time_ticks()}.tmp"
-    var ok = true
     var fend = 0ul
+    var meta_off = 0ul
+    var meta_bytes = 0ul
+    var nsections = 0
     var meta <- new MemSerializer()
     var warch = Archive(reading = false, stream = meta)
     var sections : array<ImgSection>
-    fopen(tmp_path, "wb") $(f) {
-        if (f == null) {
-            ok = false
-            return
-        }
-        // page 0: header placeholder — patched after the walk (fseek back)
-        write_zeros(f, uint64(IMAGE_PAGE))
-        var cur = uint64(IMAGE_PAGE)
-        let ts_meta = ref_time_ticks()
-        _::serialize_image_meta(warch, t)
-        to_log(LOG_INFO, "dasLLAMA image: meta serialize {get_time_usec(ts_meta) / 1000}ms\n")
+    // meta first: it needs nothing from the planes, and having it sized up front is what lets
+    // the writer preallocate the exact file (see image_total_bytes)
+    let ts_meta = ref_time_ticks()
+    _::serialize_image_meta(warch, t)
+    to_log(LOG_INFO, "dasLLAMA image: meta serialize {get_time_usec(ts_meta) / 1000}ms\n")
+    var scalar_blob <- meta->extractData()
+    unsafe {
+        delete meta
+    }
+    var w = w_open(tmp_path, image_total_bytes(t, uint64(long_length(scalar_blob)) + SECTION_TABLE_SLACK))
+    if (w.ok) {
+        w_zeros(w, uint64(IMAGE_PAGE))   // page 0: header placeholder — patched after close
         let ts_planes = ref_time_ticks()
         apply(t) $(name : string; var field) {
             static_if (typeinfo is_array(field)) {
                 static_if (!typeinfo is_string(field[0])) {   // string arrays ride the meta blob
-                    write_plane(f, sections, cur, ok, name, field)
+                    write_plane(w, sections, name, field)
                 }
             } static_elif (typeinfo safe_has_field < image_map > (field)) {
                 // a nested weight-carrier on the image rail (marker: it declares image_map) —
@@ -384,54 +457,76 @@ def save_image(var t; path : string; tag : string = "") : bool {
                 apply(field) $(iname : string; var ifield) {
                     static_if (typeinfo is_array(ifield)) {
                         static_if (!typeinfo is_string(ifield[0])) {
-                            write_plane(f, sections, cur, ok, "{name}.{iname}", ifield)
+                            write_plane(w, sections, "{name}.{iname}", ifield)
                         }
                     }
                 }
             }
         }
-        to_log(LOG_INFO, "dasLLAMA image: planes write {get_time_usec(ts_planes) / 1000}ms\n")
+        let planes_ms = int64(get_time_usec(ts_planes)) / 1000l
+        let planes_mb = int64(w.cur) >> 20l
+        to_log(LOG_INFO, "dasLLAMA image: planes write {planes_ms}ms ({planes_mb} MB at {planes_ms > 0l ? planes_mb * 1000l / planes_ms : 0l} MB/s)\n")
+        // the writer's own split — staging our bytes vs waiting on the device. Anything the two
+        // do not account for is time spent OUTSIDE the writer (the walk itself).
+        let copy_ms = int64(unsafe(dwrite_stat(w.h, 0))) / 1000000l
+        let write_ms = int64(unsafe(dwrite_stat(w.h, 1))) / 1000000l
+        let direct_mb = int64(unsafe(dwrite_stat(w.h, 2))) >> 20l
+        let bounce_mb = int64(unsafe(dwrite_stat(w.h, 3))) >> 20l
+        to_log(LOG_INFO, "dasLLAMA image:   writer split: stage {copy_ms}ms ({bounce_mb} MB bounced), syscall {write_ms}ms ({direct_mb} MB direct), unaccounted {planes_ms - copy_ms - write_ms}ms\n")
         // meta = [sections][the walk's scalar stream], one blob at the tail
         var smeta <- new MemSerializer()
         var sarch = Archive(reading = false, stream = smeta)
         sarch |> serialize(sections)
         var meta_blob <- smeta->extractData()
-        var scalar_blob <- meta->extractData()
         meta_blob |> push_from(scalar_blob)
-        let meta_off = cur
-        let meta_bytes = uint64(long_length(meta_blob))
-        f |> fwrite(meta_blob)
-        cur += meta_bytes
+        nsections = length(sections)
+        meta_off = w.cur
+        meta_bytes = uint64(long_length(meta_blob))
+        if (meta_bytes > 0ul) {   // never empty in practice — the section table always rides here
+            unsafe {
+                w_append(w, addr<void?>(meta_blob[0]), meta_bytes)
+            }
+        }
         // pad the file itself to a page multiple (the whole-file bytesNoCopy wrap needs it)
-        fend = pad_to_page(cur)
-        write_zeros(f, fend - cur)
-        // patch the header
+        fend = pad_to_page(w.cur)
+        w_zeros(w, fend - w.cur)
+        delete meta_blob
+        unsafe {
+            delete smeta
+        }
+        delete sections
+    }
+    delete scalar_blob
+    var ok = w_close(w)
+    if (ok) {
+        // the header carries counts only the finished walk knows (section count, meta offset and
+        // size), and the direct writer is append-only — so patch page 0 through an ordinary
+        // handle now that the streaming one is closed
         var hdr : array<uint8>
         hdr |> resize(int(IMAGE_HEADER_BYTES))
         store_u32(hdr, 0, IMAGE_MAGIC)
         store_u32(hdr, 4, uint(IMAGE_VERSION))
         store_u32(hdr, 8, uint(IMAGE_PAGE))
-        store_u32(hdr, 12, uint(length(sections)))
+        store_u32(hdr, 12, uint(nsections))
         store_u64(hdr, 16, meta_off)
         store_u64(hdr, 24, meta_bytes)
         store_u64(hdr, 32, fend)
         store_u64(hdr, 40, hash(image_identity(tag)))
-        fseek(f, 0l, seek_set)
-        f |> fwrite(hdr)
-        delete hdr
-        delete meta_blob
-        delete scalar_blob
-        unsafe {
-            delete smeta
+        ok = false
+        fopen(tmp_path, "r+b") $(hf) {
+            if (hf != null) {
+                fseek(hf, 0l, seek_set)
+                ok = int64(hf |> fwrite(hdr)) == IMAGE_HEADER_BYTES
+            }
         }
-        delete sections
-    }
-    unsafe {
-        delete meta
+        if (!ok) {
+            to_log(LOG_ERROR, "dasLLAMA image: '{tmp_path}' header patch failed — image save aborted\n")
+        }
+        delete hdr
     }
     if (ok) {
-        // buffered-tail backstop: the small tail writes can sit in the stdio buffer and hit
-        // ENOSPC only at fclose, which reports nothing here — verify what landed on disk
+        // last backstop: the writer reports its own failures, but an ENOSPC that only surfaces
+        // at close would still leave a short file — verify what actually landed on disk
         var st : FStat
         if (!stat(tmp_path, st) || st.size != fend) {
             to_log(LOG_ERROR, "dasLLAMA image: '{tmp_path}' is {int64(st.size)} bytes on disk, expected {int64(fend)} — disk full? image save aborted\n")
@@ -439,7 +534,8 @@ def save_image(var t; path : string; tag : string = "") : bool {
         }
     }
     if (!ok) {
-        if (!remove(tmp_path)) {
+        // a failed OPEN never created the file, so only warn about a tmp that is actually there
+        if (stat(tmp_path).is_valid && !remove(tmp_path)) {
             to_log(LOG_WARNING, "dasLLAMA image: orphaned tmp '{tmp_path}' could not be removed — clean it up by hand\n")
         }
         return false
diff --git a/src/builtin/module_builtin_fio.cpp b/src/builtin/module_builtin_fio.cpp
index a7c0c4005f..e496332943 100644
--- a/src/builtin/module_builtin_fio.cpp
+++ b/src/builtin/module_builtin_fio.cpp
@@ -43,6 +43,18 @@ MAKE_TYPE_FACTORY(clock, das::Time)// use MAKE_TYPE_FACTORY out of namespace. So
 #define getchar_wrapper getchar
 #endif
 
+// The direct sequential writer (dwrite_*): cache-bypassing, strictly-ascending append, used by
+// bulk producers that already know their total size — measured 2060 MB/s vs 275 MB/s for the same
+// volume through buffered fwrite, and it leaves the page cache to whatever the producer is READING.
+// Implemented per-platform at the bottom of this file (same split as the mmap shim above); the
+// handle owns an aligned bounce buffer, so callers append any pointer at any size.
+void * das_dwrite_open ( const char * path, uint64_t total_bytes, uint64_t band_bytes );
+bool das_dwrite_append ( void * h, const void * data, uint64_t bytes );
+void * das_dwrite_band ( void * h, uint64_t * avail );
+bool das_dwrite_commit ( void * h, uint64_t bytes );
+uint64_t das_dwrite_stat ( void * h, int which );
+bool das_dwrite_close ( void * h );
+
 namespace das {
 
     struct TimeAnnotation : ManagedValueAnnotation<Time> {
@@ -411,11 +423,9 @@ namespace das {
     }
 
     // split fmap (the prepared-model-image loader): the mapping OUTLIVES the call — the caller
-    // owns it and unmaps via fmap_close. POSIX maps PROT_READ/MAP_SHARED: OS-enforced
-    // read-only, clean droppable pages shared across processes through the page cache. The
-    // win32 mmap shim below ignores prot and maps PAGE_WRITECOPY/FILE_MAP_COPY instead —
-    // copy-on-write, so an accidental write does NOT fault there (it just privatizes the
-    // page); pages stay clean and shareable only as long as nothing writes them. The FILE
+    // owns it and unmaps via fmap_close. POSIX maps PROT_READ/MAP_SHARED and the win32 shim
+    // below maps PAGE_READONLY/FILE_MAP_READ: OS-enforced read-only on both, clean droppable
+    // pages shared across processes through the page cache, and no commit charge. The FILE
     // closes right after mapping — both POSIX and the win32 shim keep the view alive through
     // the mapping's own file reference. Failure returns null (size stays 0) rather than
     // throwing: this is a cache probe — the caller declines and regenerates from the source.
@@ -449,6 +459,51 @@ namespace das {
         munmap(data, size_t(size));
     }
 
+    // dwrite: open a file for cache-bypassing sequential append. `total_bytes` preallocates (the
+    // file is truncated back to what was actually appended at close), `band_bytes` sizes the
+    // internal aligned bounce buffer. Null on failure — the caller falls back or reports.
+    void * builtin_dwrite_open ( const char * name, uint64_t total_bytes, uint64_t band_bytes,
+                                 Context * context, LineInfoArg * at ) {
+        if ( !name ) context->throw_error_at(at, "dwrite_open: null path");
+        return das_dwrite_open(name, total_bytes, band_bytes);
+    }
+
+    // append `bytes` at the current end. Any pointer, any size — the handle re-blocks into
+    // aligned bands internally. false = the write failed (ENOSPC in practice); a failed writer
+    // stays failed, so callers can check once at close instead of per append.
+    bool builtin_dwrite_append ( void * h, void * data, uint64_t bytes, Context * context, LineInfoArg * at ) {
+        if ( !h ) context->throw_error_at(at, "dwrite_append: null writer");
+        if ( !data && bytes ) context->throw_error_at(at, "dwrite_append: null data");
+        return das_dwrite_append(h, data, bytes);
+    }
+
+    // the writer's own staging buffer, for producers that would otherwise build a band and then
+    // copy it in. `avail` reports what is left in the current band; fill up to that and commit.
+    void * builtin_dwrite_band ( void * h, uint64_t * avail, Context * context, LineInfoArg * at ) {
+        if ( !h ) context->throw_error_at(at, "dwrite_band: null writer");
+        if ( !avail ) context->throw_error_at(at, "dwrite_band: null avail out-param");
+        return das_dwrite_band(h, avail);
+    }
+
+    bool builtin_dwrite_commit ( void * h, uint64_t bytes, Context * context, LineInfoArg * at ) {
+        if ( !h ) context->throw_error_at(at, "dwrite_commit: null writer");
+        return das_dwrite_commit(h, bytes);
+    }
+
+    // where the writer spent its time: 0 = staging ns, 1 = syscall ns, 2 = direct bytes,
+    // 3 = bounced bytes. Call before dwrite_close — the handle is gone after.
+    uint64_t builtin_dwrite_stat ( void * h, int32_t which, Context * context, LineInfoArg * at ) {
+        if ( !h ) context->throw_error_at(at, "dwrite_stat: null writer");
+        return das_dwrite_stat(h, int(which));
+    }
+
+    // flush the tail, truncate to the appended size, close. false if anything along the way
+    // failed — the ONLY completion check a caller needs.
+    bool builtin_dwrite_close ( void * h, Context * context, LineInfoArg * at ) {
+        if ( !h ) context->throw_error_at(at, "dwrite_close: null writer");
+        return das_dwrite_close(h);
+    }
+
     // plain ftell/fseek take `long`, which is 32-bit on Windows (LLP64) — use the explicit
     // 64-bit forms so offsets past 2GB survive on every platform
     int64_t builtin_ftell ( const FILE * f, Context * context, LineInfoArg * at ) {
@@ -2251,6 +2306,24 @@ namespace das {
             addExtern<DAS_BIND_FUN(builtin_fmap_close)>(*this, lib, "fmap_close",
                 SideEffects::modifyExternal, "builtin_fmap_close")
                     ->args({"data","size","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_dwrite_open)>(*this, lib, "dwrite_open",
+                SideEffects::modifyExternal, "builtin_dwrite_open")
+                    ->args({"path","total_bytes","band_bytes","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_dwrite_append)>(*this, lib, "dwrite_append",
+                SideEffects::modifyExternal, "builtin_dwrite_append")
+                    ->args({"writer","data","bytes","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_dwrite_band)>(*this, lib, "dwrite_band",
+                SideEffects::modifyExternal, "builtin_dwrite_band")
+                    ->args({"writer","avail","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_dwrite_commit)>(*this, lib, "dwrite_commit",
+                SideEffects::modifyExternal, "builtin_dwrite_commit")
+                    ->args({"writer","bytes","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_dwrite_stat)>(*this, lib, "dwrite_stat",
+                SideEffects::modifyExternal, "builtin_dwrite_stat")
+                    ->args({"writer","which","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_dwrite_close)>(*this, lib, "dwrite_close",
+                SideEffects::modifyExternal, "builtin_dwrite_close")
+                    ->args({"writer","context","line"})->unsafeOperation = true;
             addExtern<DAS_BIND_FUN(builtin_fgets)>(*this, lib, "fgets",
                 SideEffects::modifyExternal, "builtin_fgets")
                     ->args({"file","context","line"});
@@ -2481,10 +2554,16 @@ void * mmap (void* start, size_t length, int /*prot*/, int /*flags*/, int fd, of
     len = (size_t)st.st_size;
     if ((length + offset) > len)
         length = len - offset;
-    hmap = CreateFileMapping((HANDLE)_get_osfhandle(fd), 0, PAGE_WRITECOPY, 0, 0, 0);
+    // PAGE_READONLY, not PAGE_WRITECOPY: a copy-on-write section makes Windows reserve backing
+    // store for every page that COULD be privatized, so it charges commit for the whole view —
+    // a 73 GB gguf mapping showed up as 73 GB of private bytes on top of the model itself
+    // (measured 2026-07-27: 149.9 GB private for a 78 GB image). Read-only maps charge nothing,
+    // match what POSIX already does here (PROT_READ), and fault loudly on an accidental write
+    // instead of silently privatizing the page.
+    hmap = CreateFileMapping((HANDLE)_get_osfhandle(fd), 0, PAGE_READONLY, 0, 0, 0);
     if (!hmap)
         return MAP_FAILED;
-    temp = MapViewOfFileEx(hmap, FILE_MAP_COPY, h, l, length, start);
+    temp = MapViewOfFileEx(hmap, FILE_MAP_READ, h, l, length, start);
     if (!CloseHandle(hmap))
         fprintf(stderr, "unable to close file mapping handle\n");
     return temp ? temp : MAP_FAILED;
@@ -2496,4 +2575,313 @@ int munmap ( void* start, size_t ) {
 
 #endif
 
+// ===== dwrite: the direct sequential writer =====
+
+#if DAS_NO_FILEIO
+
+void * das_dwrite_open ( const char *, uint64_t, uint64_t ) { return nullptr; }
+bool das_dwrite_append ( void *, const void *, uint64_t ) { return false; }
+void * das_dwrite_band ( void *, uint64_t * avail ) { if ( avail ) *avail = 0; return nullptr; }
+bool das_dwrite_commit ( void *, uint64_t ) { return false; }
+uint64_t das_dwrite_stat ( void *, int ) { return 0; }
+bool das_dwrite_close ( void * ) { return false; }
+
+#else
+
+// The bounce buffer is what makes the API take any pointer at any size: FILE_FLAG_NO_BUFFERING
+// demands sector-aligned buffer, offset AND count, and O_DIRECT-class paths elsewhere want the
+// same. Re-blocking costs one memcpy at memory bandwidth against a ~2 GB/s device — noise.
+struct DasDirectWriter {
+    uint8_t *   band = nullptr;
+    uint64_t    band_bytes = 0;
+    uint64_t    fill = 0;          // bytes currently staged in `band`
+    uint64_t    written = 0;       // bytes handed to the OS so far
+    uint64_t    align = 1;         // sector size on win32, 1 elsewhere
+    bool        ok = true;
+    // where the time actually goes — staging the caller's bytes vs waiting on the device. Read
+    // back with dwrite_stat; the split is what separates "our memory reads are slow" from
+    // "the device is slow", which no external probe can distinguish from outside.
+    uint64_t    copy_ns = 0;
+    uint64_t    write_ns = 0;
+    uint64_t    direct_bytes = 0;  // bypassed the band (already aligned)
+    uint64_t    bounce_bytes = 0;  // staged through the band
+#if _WIN32
+    HANDLE      h = INVALID_HANDLE_VALUE;
+    wchar_t *   wpath = nullptr;   // kept for the close-time truncate (NO_BUFFERING can't set EOF)
+#else
+    int         fd = -1;
+#endif
+};
+
+static const uint64_t DAS_DWRITE_DEFAULT_BAND = 16u << 20;
+
+static inline uint64_t das_dwrite_now_ns () {
+    return (uint64_t) std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+#if _WIN32
+
+void * das_dwrite_open ( const char * path, uint64_t total_bytes, uint64_t band_bytes ) {
+    if ( !path ) return nullptr;
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, path, -1, nullptr, 0);
+    if ( wlen <= 0 ) return nullptr;
+    wchar_t * wpath = (wchar_t *) malloc(sizeof(wchar_t) * wlen);
+    if ( !wpath ) return nullptr;
+    MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, wlen);
+    // sector size decides the alignment NO_BUFFERING enforces; fall back to 4096 if the volume
+    // won't say (a path with no drive letter, a UNC share)
+    DWORD sector = 4096;
+    if ( wlen > 2 && wpath[1] == L':' ) {
+        wchar_t root[4] = { wpath[0], L':', L'\\', 0 };
+        DWORD spc = 0, bps = 0, freec = 0, totalc = 0;
+        if ( GetDiskFreeSpaceW(root, &spc, &bps, &freec, &totalc) && bps ) sector = bps;
+    }
+    HANDLE h = CreateFileW(wpath, GENERIC_WRITE, FILE_SHARE_READ, nullptr, CREATE_ALWAYS,
+        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
+    if ( h == INVALID_HANDLE_VALUE ) {
+        free(wpath);
+        return nullptr;
+    }
+    // preallocate: NTFS lays the run down contiguously, and because every write below is strictly
+    // ascending the valid-data-length watermark advances with them — no zero-fill is ever charged
+    if ( total_bytes ) {
+        LARGE_INTEGER li;
+        li.QuadPart = (LONGLONG) total_bytes;
+        if ( SetFilePointerEx(h, li, nullptr, FILE_BEGIN) ) SetEndOfFile(h);
+        li.QuadPart = 0;
+        SetFilePointerEx(h, li, nullptr, FILE_BEGIN);
+    }
+    DasDirectWriter * w = new DasDirectWriter();
+    w->align = sector;
+    w->band_bytes = band_bytes ? band_bytes : DAS_DWRITE_DEFAULT_BAND;
+    w->band_bytes = ((w->band_bytes + sector - 1) / sector) * sector;
+    w->band = (uint8_t *) VirtualAlloc(nullptr, (SIZE_T) w->band_bytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    w->h = h;
+    w->wpath = wpath;
+    if ( !w->band ) {
+        CloseHandle(h);
+        free(wpath);
+        delete w;
+        return nullptr;
+    }
+    return w;
+}
+
+// push exactly `bytes` (already a multiple of the sector size) from a sector-aligned pointer
+static bool das_dwrite_raw ( DasDirectWriter * w, const uint8_t * src, uint64_t bytes ) {
+    uint64_t at = 0;
+    while ( at < bytes ) {
+        uint64_t left = bytes - at;
+        DWORD chunk = (DWORD) (left < uint64_t(1u << 30) ? left : uint64_t(1u << 30));
+        DWORD wrote = 0;
+        if ( !WriteFile(w->h, src + at, chunk, &wrote, nullptr) || wrote != chunk ) return false;
+        at += wrote;
+    }
+    w->written += bytes;
+    return true;
+}
+
+bool das_dwrite_close ( void * hh ) {
+    DasDirectWriter * w = (DasDirectWriter *) hh;
+    if ( !w ) return false;
+    uint64_t final_bytes = w->written + w->fill;
+    if ( w->ok && w->fill ) {
+        // the tail: pad to a sector so NO_BUFFERING accepts it, then truncate below
+        uint64_t padded = ((w->fill + w->align - 1) / w->align) * w->align;
+        memset(w->band + w->fill, 0, (size_t)(padded - w->fill));
+        w->ok = das_dwrite_raw(w, w->band, padded);
+        w->fill = 0;
+    }
+    bool ok = w->ok;
+    CloseHandle(w->h);
+    // NO_BUFFERING can't set a non-sector EOF, and the preallocation left the file at its full
+    // reserved size — reopen normally to cut it back to what was actually appended
+    if ( ok ) {
+        HANDLE t = CreateFileW(w->wpath, GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+            FILE_ATTRIBUTE_NORMAL, nullptr);
+        if ( t != INVALID_HANDLE_VALUE ) {
+            LARGE_INTEGER li;
+            li.QuadPart = (LONGLONG) final_bytes;
+            if ( !SetFilePointerEx(t, li, nullptr, FILE_BEGIN) || !SetEndOfFile(t) ) ok = false;
+            CloseHandle(t);
+        } else {
+            ok = false;
+        }
+    }
+    VirtualFree(w->band, 0, MEM_RELEASE);
+    free(w->wpath);
+    delete w;
+    return ok;
+}
+
+#else
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+void * das_dwrite_open ( const char * path, uint64_t total_bytes, uint64_t band_bytes ) {
+    if ( !path ) return nullptr;
+    int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    if ( fd < 0 ) return nullptr;
+    DasDirectWriter * w = new DasDirectWriter();
+    w->fd = fd;
+    w->band_bytes = band_bytes ? band_bytes : DAS_DWRITE_DEFAULT_BAND;
+    w->band = (uint8_t *) malloc((size_t) w->band_bytes);
+    if ( !w->band ) {
+        close(fd);
+        delete w;
+        return nullptr;
+    }
+#if defined(__APPLE__)
+    fcntl(fd, F_NOCACHE, 1);            // the APFS/HFS equivalent of NO_BUFFERING
+    if ( total_bytes ) {
+        fstore_t st = { F_ALLOCATECONTIG | F_ALLOCATEALL, F_PEOFPOSMODE, 0, (off_t) total_bytes, 0 };
+        if ( fcntl(fd, F_PREALLOCATE, &st) < 0 ) {
+            st.fst_flags = F_ALLOCATEALL;   // contiguous is a preference, not a requirement
+            fcntl(fd, F_PREALLOCATE, &st);
+        }
+    }
+#else
+    if ( total_bytes ) {
+        if ( posix_fallocate(fd, 0, (off_t) total_bytes) != 0 ) {
+            // filesystems without fallocate (or a full disk) — the appends below still work,
+            // they just extend the file the ordinary way
+        }
+    }
+#endif
+    return w;
+}
+
+static bool das_dwrite_raw ( DasDirectWriter * w, const uint8_t * src, uint64_t bytes ) {
+    uint64_t at = 0;
+    while ( at < bytes ) {
+        ssize_t wrote = write(w->fd, src + at, (size_t)(bytes - at));
+        if ( wrote <= 0 ) {
+            if ( errno == EINTR ) continue;
+            return false;
+        }
+        at += (uint64_t) wrote;
+    }
+#if !defined(__APPLE__)
+    // hand the just-written range back to the OS: the producer is streaming a much larger source
+    // through the same page cache, and these pages will never be read again
+    off_t from = (off_t) w->written;
+    posix_fadvise(w->fd, from, (off_t) bytes, POSIX_FADV_DONTNEED);
+#endif
+    w->written += bytes;
+    return true;
+}
+
+bool das_dwrite_close ( void * hh ) {
+    DasDirectWriter * w = (DasDirectWriter *) hh;
+    if ( !w ) return false;
+    uint64_t final_bytes = w->written + w->fill;
+    if ( w->ok && w->fill ) {
+        w->ok = das_dwrite_raw(w, w->band, w->fill);
+        w->fill = 0;
+    }
+    bool ok = w->ok;
+    if ( ok && ftruncate(w->fd, (off_t) final_bytes) != 0 ) ok = false;
+    close(w->fd);
+    free(w->band);
+    delete w;
+    return ok;
+}
+
+#endif
+
+// platform-independent half: stage into the band, push whenever it fills. A writer that has
+// already failed stays failed and stops touching the disk.
+bool das_dwrite_append ( void * hh, const void * data, uint64_t bytes ) {
+    DasDirectWriter * w = (DasDirectWriter *) hh;
+    if ( !w || !w->ok ) return false;
+    const uint8_t * src = (const uint8_t *) data;
+    while ( bytes ) {
+        // bulk fast path: on a band boundary, a band-sized-or-larger run from an already-aligned
+        // source goes straight to the device, skipping a full memcpy of the payload (~10% of wall
+        // time at 2 GB/s). Checked per iteration, not once on entry — a plane rarely starts on a
+        // band boundary, but it reaches one after the first partial band and the rest is bulk.
+        if ( w->fill == 0 && bytes >= w->band_bytes && (uintptr_t(src) % w->align) == 0 ) {
+            uint64_t direct = (bytes / w->align) * w->align;
+            uint64_t t0 = das_dwrite_now_ns();
+            bool wok = das_dwrite_raw(w, src, direct);
+            w->write_ns += das_dwrite_now_ns() - t0;
+            w->direct_bytes += direct;
+            if ( !wok ) {
+                w->ok = false;
+                return false;
+            }
+            src += direct;
+            bytes -= direct;
+            continue;   // whatever is left is a sub-sector tail for the band below
+        }
+        uint64_t room = w->band_bytes - w->fill;
+        uint64_t take = bytes < room ? bytes : room;
+        uint64_t tc = das_dwrite_now_ns();
+        memcpy(w->band + w->fill, src, (size_t) take);
+        w->copy_ns += das_dwrite_now_ns() - tc;
+        w->bounce_bytes += take;
+        w->fill += take;
+        src += take;
+        bytes -= take;
+        if ( w->fill == w->band_bytes ) {
+            uint64_t t0 = das_dwrite_now_ns();
+            bool wok = das_dwrite_raw(w, w->band, w->band_bytes);
+            w->write_ns += das_dwrite_now_ns() - t0;
+            if ( !wok ) {
+                w->ok = false;
+                return false;
+            }
+            w->fill = 0;
+        }
+    }
+    return true;
+}
+
+// band/commit: hand the producer the writer's own aligned staging buffer so it can build bytes
+// straight into it — no intermediate allocation, no bounce copy. `avail` is what's left in the
+// current band; commit what you filled and the band flushes itself when it tops out.
+// 0 = ns spent staging caller bytes into the band, 1 = ns spent inside write syscalls,
+// 2 = bytes written straight from the caller, 3 = bytes staged through the band.
+uint64_t das_dwrite_stat ( void * hh, int which ) {
+    DasDirectWriter * w = (DasDirectWriter *) hh;
+    if ( !w ) return 0;
+    switch ( which ) {
+        case 0: return w->copy_ns;
+        case 1: return w->write_ns;
+        case 2: return w->direct_bytes;
+        case 3: return w->bounce_bytes;
+        default: return 0;
+    }
+}
+
+void * das_dwrite_band ( void * hh, uint64_t * avail ) {
+    DasDirectWriter * w = (DasDirectWriter *) hh;
+    if ( !w || !w->ok ) {
+        if ( avail ) *avail = 0;
+        return nullptr;
+    }
+    if ( avail ) *avail = w->band_bytes - w->fill;
+    return w->band + w->fill;
+}
+
+bool das_dwrite_commit ( void * hh, uint64_t bytes ) {
+    DasDirectWriter * w = (DasDirectWriter *) hh;
+    if ( !w || !w->ok ) return false;
+    if ( w->fill + bytes > w->band_bytes ) return false;   // the producer overran its own band
+    w->fill += bytes;
+    if ( w->fill == w->band_bytes ) {
+        if ( !das_dwrite_raw(w, w->band, w->band_bytes) ) {
+            w->ok = false;
+            return false;
+        }
+        w->fill = 0;
+    }
+    return true;
+}
+
+#endif
+
 REGISTER_MODULE_IN_NAMESPACE(Module_FIO,das);
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
new file mode 100644
index 0000000000..3fc040a4d6
--- /dev/null
+++ b/utils/dasllama-convert/main.das
@@ -0,0 +1,180 @@
+options gen2
+options stack = 65536   // dasLLAMA program-root convention (options stack does not unify up from libs)
+
+// dasllama-convert — turn a GGUF into a prepared .dlim image, offline.
+//
+//   bin/daslang -jit utils/dasllama-convert/main.das -- -m <model.gguf> [-o <out.dlim>] [-q q8]
+//
+// The image is BOX- AND KNOB-specific (see image_identity in dasllama_image.das), so the default
+// output name carries the identity hash and is exactly what the normal load path looks for — run
+// this ahead of time and the first real load maps instead of converting. `--flavor` picks which
+// image a config with several flavors emits (planar CPU, metal blob, vulkan-baked).
+//
+// Conversion is I/O bound at both ends: the transcode is ~5% of wall time, the rest is reading the
+// GGUF and writing the image. Both numbers are reported per stage so a slow box is diagnosable
+// without a profiler.
+
+require dasllama/dasllama_transformer   // nolint:STYLE029 — umbrella fires each arch [init] registration
+require dasllama/dasllama_math          // apply_box_profile_runtime + select_matmul_backend_for_load
+require dasllama/dasllama_image         // the .dlim rail itself
+require dasllama/dasllama_layout        // convert_model_to_metal_blob — the metal flavor's transform
+require daslib/clargs
+require daslib/jobque_boost
+require daslib/fio
+require daslib/strings_boost
+require strings
+
+
+enum private Flavor {
+    planar      // the CPU image every box can load
+    metal       // blob-only Apple flavor (METAL_IMAGE_TAG)
+    vulkan      // planar + baked GPU-layout planes
+}
+
+[CommandLineArgs]
+struct ConvertArgs {
+    // deliberately NOT @clarg_required: that check fires before the help branch, so
+    // `--show-help` alone would exit 2 with an error line. Validated by hand below instead.
+    @clarg_short = "m"
+    @clarg_doc = "Source GGUF path (the FIRST shard for split models)"
+    model : string
+
+    @clarg_short = "o"
+    @clarg_doc = "Output .dlim path (default: the identity-hashed name beside the GGUF, which is what the load path looks for)"
+    out : string
+
+    @clarg_short = "q"
+    @clarg_doc = "Weight quant mode (default: q8)"
+    quant : QuantMode = QuantMode.q8
+
+    @clarg_short = "f"
+    @clarg_doc = "Which image flavor to emit (default: planar)"
+    flavor : Flavor = Flavor.planar
+
+    @clarg_doc = "Convert even if a valid image is already there (default: report it and exit 0)"
+    force : bool
+
+    @clarg_doc = "Do NOT remove stale '*.dlim.<ticks>.tmp' siblings left behind by killed runs"
+    keep_stale_tmp : bool
+
+    @clarg_name = "show-help"
+    @clarg_doc = "Show this help and exit"
+    help : bool
+}
+
+// A killed converter leaves its tmp behind — save_image only removes its own on a CLEAN failure.
+// They are full-size (95 GB each was found on this box), so sweep them before writing another.
+def private sweep_stale_tmp(gguf : string) : int {
+    let dir_path = dir_name(gguf)
+    let base = base_name(gguf)
+    var freed = 0l
+    var n = 0
+    dir(dir_path) $(name : string) {
+        // only OUR tmp shape (<gguf>….dlim.<ticks>.tmp) — never an unrelated .tmp
+        if (!(name |> starts_with(base)) || !(name |> ends_with(".tmp")) || find(name, ".dlim.") < 0) {
+            return
+        }
+        let full = path_join(dir_path, name)
+        var st : FStat
+        if (!stat(full, st) || st.is_dir) {
+            return
+        }
+        let bytes = int64(st.size)
+        if (remove(full)) {
+            freed += bytes
+            n++
+            to_log(LOG_INFO, "dasllama-convert: removed stale tmp {name} ({bytes >> 20l} MB)\n")
+        } else {
+            to_log(LOG_WARNING, "dasllama-convert: could not remove stale tmp {name} — in use by a live converter?\n")
+        }
+    }
+    if (n > 0) {
+        to_log(LOG_INFO, "dasllama-convert: reclaimed {freed >> 30l} GB from {n} stale tmp file(s)\n")
+    }
+    return n
+}
+
+def private flavor_tag(f : Flavor) : string {
+    if (f == Flavor.metal) {
+        return METAL_IMAGE_TAG
+    }
+    if (f == Flavor.vulkan) {
+        let cfg = moe_gpu_bake_tag()
+        if (cfg == "") {
+            panic("dasllama-convert: --flavor vulkan needs the vulkan tier armed (see DASLLAMA_GPU_* in modules/dasLLAMA/ENVIRONMENT.md)")
+        }
+        return "vulkan|{cfg}"
+    }
+    return ""
+}
+
+[export]
+def main() : int {
+    var args_r <- parse_args(type<ConvertArgs>)
+    if (args_r |> is_err) {
+        to_log(LOG_ERROR, "error: {args_r |> unwrap_err}\n\n")
+        print_help(get_command_info(type<ConvertArgs>), "dasllama-convert")
+        return 2
+    }
+    let cfg <- args_r |> move_unwrap
+    if (cfg.help) {
+        print_help(get_command_info(type<ConvertArgs>), "dasllama-convert")
+        return 0
+    }
+    if (cfg.model == "") {
+        to_log(LOG_ERROR, "dasllama-convert: --model is required\n\n")
+        print_help(get_command_info(type<ConvertArgs>), "dasllama-convert")
+        return 2
+    }
+    if (!stat(cfg.model).is_valid) {
+        to_log(LOG_ERROR, "dasllama-convert: no such GGUF '{cfg.model}'\n")
+        return 2
+    }
+    if (cfg.model |> ends_with(".dlim")) {
+        to_log(LOG_ERROR, "dasllama-convert: '{cfg.model}' is already a prepared image — this tool converts GGUF -> .dlim\n")
+        return 2
+    }
+    // the backend pin must precede the identity: image_identity names the active kernel backend
+    apply_box_profile_runtime()
+    let tag = flavor_tag(cfg.flavor)
+    let out = cfg.out != "" ? cfg.out : image_path_for(cfg.model, tag)
+    to_log(LOG_INFO, "dasllama-convert: {cfg.model}\n")
+    to_log(LOG_INFO, "dasllama-convert:   -> {out}\n")
+    to_log(LOG_INFO, "dasllama-convert:   identity {image_identity(tag)}\n")
+
+    if (!cfg.keep_stale_tmp) {
+        sweep_stale_tmp(cfg.model)
+    }
+    if (!cfg.force && stat(out).is_valid) {
+        to_log(LOG_INFO, "dasllama-convert: image already present — nothing to do (use --force to rebuild)\n")
+        return 0
+    }
+
+    var rc = 0
+    let ts = ref_time_ticks()
+    // the job que carries the transcode/repack passes; the load spins its own if we do not
+    with_job_que() {
+        var m <- load_model_(cfg.model, cfg.quant)
+        let ts_load = ref_time_ticks()
+        if (cfg.flavor == Flavor.metal) {
+            if (!metal_model_servable(m) || !convert_model_to_metal_blob(m)) {
+                to_log(LOG_ERROR, "dasllama-convert: this config has no metal-servable blob flavor\n")
+                rc = 1
+            }
+        }
+        if (rc == 0 && !save_model_image(m, out, tag)) {
+            to_log(LOG_ERROR, "dasllama-convert: writing '{out}' failed — see the error above\n")
+            rc = 1
+        }
+        if (rc == 0) {
+            var st : FStat
+            let bytes = stat(out, st) ? int64(st.size) : 0l
+            let save_ms = int64(get_time_usec(ts_load)) / 1000l
+            let total_ms = int64(get_time_usec(ts)) / 1000l
+            let mb = bytes >> 20l
+            to_log(LOG_INFO, "dasllama-convert: wrote {mb} MB in {save_ms} ms ({save_ms > 0l ? mb * 1000l / save_ms : 0l} MB/s), {total_ms} ms total\n")
+        }
+        delete m
+    }
+    return rc
+}

From 64459e2deff130b6dfa04372d7594046ecba218a Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 20:41:00 -0700
Subject: [PATCH 03/30] =?UTF-8?q?dlim=20arc=20phase=20A:=20explicit=20Dlim?=
 =?UTF-8?q?Configuration=20=E2=80=94=20identity=20is=20a=20pure=20formatte?=
 =?UTF-8?q?r,=20config=20rides=20the=20image=20meta?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The .dlim bake config is now ONE explicit struct (dasllama_config.das) instead of scattered
host probes: cpu section (backend + layout numbers + native/wscale OUTCOMES), vulkan section
(RESOLVED coopmat mode / vram_mb / all walk-shaping bits — the old tag folded raw env strings
and missed the dense bits + the cls default split), metal section. Tiers register section
sources at [init]; image_identity(tag) = dlim_identity(config, IMAGE_VERSION, tag), no side
effects (the backend select lives in the cpu source). vk_moe_init's coopmat ladder and budget
resolution extracted into shared resolvers (resolve_coopmat_mode / resolve_weight_cap — auto
vram now rounds down to 256 MB so the identity doesn't churn with heap wiggle) so the config
can never drift from what the device runs; the caps probe is phys-level only, the 518ae164a
stream-reserve carve stays in vk_moe_init.

IMAGE_VERSION 6 -> 7: the meta blob now leads with [identity string][config JSON], so an
identity-mismatched load logs "baked for '<X>', this run is '<Y>'" instead of a bare hash miss
(bounds checks moved ahead of the identity check to make that read safe; a wrong-version image
still declines on the header alone).

dasllama-convert: --dump-config writes this box's config JSON (+ identity); --config x.json
bakes against a supplied one — host-independent knobs applied, then FAIL-CLOSED verified
against the resulting identity (an unavailable backend errors with want/have strings; true
cross-box repack-by-numbers is a later arc slice). dlim_config_from_json tolerates a UTF-8 BOM.
Also fixed: quant_from_string took `var q : QuantMode` — a workhorse-type COPY, so the parsed
quant never reached the caller; LINT003 flagged the dead write and was right. Now QuantMode&.

tests/run.das now works on Windows at all: the env prefix was POSIX-only (cmd.exe has no
VAR=val prefix — now `set "VAR=..."&&` like llvm_tune's tuner_cmd), the log dir fell back to a
nonexistent /tmp (now TMPDIR -> TEMP -> /tmp), and the default binary ./bin/daslang picked up a
STALE top-level exe on the MSVC layout (now the binary running the script). TEMP registered in
env_registry (the tripwire caught the new read); utils/dasllama-convert added to the registry
scan roots.

Gates: test_model_image mechanics arm 9/9 (synthetic carrier + header-patch decline matrix),
smol arm 8/8 (real SmolLM2 regenerated at v7 with the embedded config, mapped back),
test_env_registry 14/14, lint clean on every touched file, das-fmt clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/.das_module                  |   2 +-
 modules/dasLLAMA/ENVIRONMENT.md               |   1 +
 modules/dasLLAMA/dasllama/dasllama_common.das |  39 +++-
 modules/dasLLAMA/dasllama/dasllama_config.das | 143 +++++++++++++
 modules/dasLLAMA/dasllama/dasllama_env.das    |   2 +
 modules/dasLLAMA/dasllama/dasllama_image.das  |  68 ++++--
 modules/dasLLAMA/dasllama/dasllama_math.das   |   6 +
 .../dasllama/dasllama_math_vulkan.das         | 201 ++++++++++++------
 modules/dasLLAMA/tests/run.das                |  32 ++-
 modules/dasLLAMA/tests/test_env_registry.das  |   1 +
 utils/dasllama-convert/main.das               |  91 +++++++-
 11 files changed, 495 insertions(+), 91 deletions(-)
 create mode 100644 modules/dasLLAMA/dasllama/dasllama_config.das

diff --git a/modules/dasLLAMA/.das_module b/modules/dasLLAMA/.das_module
index 077ed5758d..3783b947a4 100644
--- a/modules/dasLLAMA/.das_module
+++ b/modules/dasLLAMA/.das_module
@@ -4,7 +4,7 @@ require daslib/fio
 [export]
 def initialize(project_path : string) {
     let dasllama_paths = [
-        "dasllama_env", "dasllama_par", "dasllama_parity", "dasllama_tune", "dasllama_math", "dasllama_math_default", "dasllama_math_aarch64_neon", "dasllama_math_gen", "dasllama_math_metal", "dasllama_math_vulkan", "dasllama_math_accelerate", "dasllama_kernel_access", "dasllama_vulkan_lens", "dasllama_metal_lens", "dasllama_metal_common", "dasllama_metal_kernels", "dasllama_metal_prefill", "dasllama_metal_llama", "dasllama_gemm_gen", "dasllama_gemm_register", "dasllama_gemm_schema", "dasllama_quant", "dasllama_gguf",
+        "dasllama_env", "dasllama_config", "dasllama_par", "dasllama_parity", "dasllama_tune", "dasllama_math", "dasllama_math_default", "dasllama_math_aarch64_neon", "dasllama_math_gen", "dasllama_math_metal", "dasllama_math_vulkan", "dasllama_math_accelerate", "dasllama_kernel_access", "dasllama_vulkan_lens", "dasllama_metal_lens", "dasllama_metal_common", "dasllama_metal_kernels", "dasllama_metal_prefill", "dasllama_metal_llama", "dasllama_gemm_gen", "dasllama_gemm_register", "dasllama_gemm_schema", "dasllama_quant", "dasllama_gguf",
         "dasllama_unicode", "dasllama_tokenizer", "dasllama_bpe", "dasllama_common", "dasllama_layout", "dasllama_prefix", "dasllama_audio", "dasllama_audio_io", "dasllama_whisper", "dasllama_qwen3a", "dasllama_parakeet", "dasllama_canary", "dasllama_gemma4a", "dasllama_vad", "dasllama_asr",
         "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_gptoss", "dasllama_arch_mistral3", "dasllama_arch_glm4moe", "dasllama_image",
         "dasllama_transformer", "dasllama_chat", "dasllama"
diff --git a/modules/dasLLAMA/ENVIRONMENT.md b/modules/dasLLAMA/ENVIRONMENT.md
index 3baefe49dd..92be63f40a 100644
--- a/modules/dasLLAMA/ENVIRONMENT.md
+++ b/modules/dasLLAMA/ENVIRONMENT.md
@@ -187,6 +187,7 @@ Apple Accelerate / AMX float lane. `DASLLAMA_ACCEL` arms the whole group.
 | `DASLLAMA_WHISPER_DIR` | path | unset | Directory of whisper models for the audio tests. |
 | `DASLLAMA_CORPUS_DIR` | path | unset | Directory of audio corpus files for the transcription tests. |
 | `TMPDIR` | path | /tmp | Scratch directory for test artifacts; set by the OS on macOS. |
+| `TEMP` | path | unset | Windows scratch-directory fallback when TMPDIR is unset (the test runner's log dir). |
 
 ## Examples and tutorials
 
diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index 25eb878bbb..fc9e6950d4 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -5,6 +5,7 @@ module dasllama_common shared public
 
 require daslib/fio
 require dasllama/dasllama_env  // the shared typed env readers + the knob registry
+require dasllama/dasllama_config  // DlimConfiguration — this module registers the cpu/metal sources
 require daslib/array_boost // nolint:STYLE030 — temp_array is [template]; STYLE030 misses template-fn refs and false-flags this as unused
 require dasllama/dasllama_math
 require dasllama/dasllama_math_default  // registers the portable Q8·Q8 backend at [init] (the fallback everywhere)
@@ -1793,6 +1794,42 @@ def public get_kq_q51_native() : bool {
     return g_kq_q51_native
 }
 
+// ===== DlimConfiguration sources (dasllama_config) =====
+
+def private dlim_cpu_source_impl(var c : DlimCpuConfig) {
+    // the one sanctioned backend-select side effect — the identity itself is a pure formatter
+    select_matmul_backend_for_load()
+    c.backend = active_kernel_backend()
+    c.q8_mr = active_q8_layout_mr()
+    c.q8_wbias = active_q8_wbias()
+    c.q8_kgroup = active_q8_kgroup()
+    c.kq_mr4 = active_kq_layout_mr(4)
+    c.kq_mr5 = active_kq_layout_mr(5)
+    c.kq_mr6 = active_kq_layout_mr(6)
+    c.kq_mr40 = active_kq_layout_mr(40)
+    c.q51_mr = active_q51_layout_mr()
+    // OUTCOME, not request: a backend without s16 twins keeps f32 scale planes (wscale_convert_f16)
+    c.wscale_f16 = g_wscale_f16 && kernel_backend_has_wscale16()
+    c.kquant_native = g_kquant_native
+    c.kq_q40_native = g_kq_q40_native
+    c.kq_q50_native = g_kq_q50_native
+    c.kq_q51_native = g_kq_q51_native
+}
+
+def private dlim_metal_source_impl(var c : DlimMetalConfig) : bool {
+    if (get_metal_mode() == MetalMode.off || !has_decode_override("metal")) {
+        return false
+    }
+    c.mode = "{get_metal_mode()}"
+    return true
+}
+
+[init]
+def dlim_config_sources_register() {
+    set_dlim_cpu_source(@@dlim_cpu_source_impl)
+    set_dlim_metal_source(@@dlim_metal_source_impl)
+}
+
 def private count_fmt(a : array<KqFmt>; f : KqFmt) : int {
     var n = 0
     for (x in a) {
@@ -2764,7 +2801,7 @@ def moe_gpu_upload_resident(t : Model) {
     // DASLLAMA_GPU_CLS=0 keeps it on the CPU (A/B lever).
     let cls_fmt = t.config.shared_weights ? t.emb_fmt : t.wcls_fmt
     let cls_servable = cls_fmt == KqFmt.q8 ? (t.cls_q8 || !t.config.shared_weights) : moe_gpu_fmt_kq(cls_fmt)
-    if (cls_servable && env_flag("DASLLAMA_GPU_CLS", true)
+    if (cls_servable && gpu_want_cls_upload()
             && moe_gpu_gather_upload(t, cls_fmt, t.wcls_off, dim, t.config.vocab_size, t.config.vocab_size, mr, kgroup, wbias, wq, ws)) {
         set_moe_gpu_cls_off(t.wcls_off)
     }
diff --git a/modules/dasLLAMA/dasllama/dasllama_config.das b/modules/dasLLAMA/dasllama/dasllama_config.das
new file mode 100644
index 0000000000..b78f1c7a67
--- /dev/null
+++ b/modules/dasLLAMA/dasllama/dasllama_config.das
@@ -0,0 +1,143 @@
+options gen2
+options _comment_hygiene = true
+
+//! The explicit .dlim bake configuration: every input that changes image BYTES, in one struct —
+//! built at load time from the live box, suppliable to the converter as JSON, embedded in the
+//! image meta. The identity is a pure formatter of this struct; nothing in here probes the host.
+//!
+//! Discipline rule: a knob that changes image bytes MUST be a field here (missing = silent stale
+//! images); a serve-only knob MUST NOT be (present = spurious rebakes on every knob flip).
+
+module dasllama_config shared public
+
+require strings
+require daslib/utf8_utils
+
+//! The CPU tier's layout half: which backend's repack shapes the planes, its interleave numbers,
+//! and the scale/native-format outcomes. `wscale_f16` is the OUTCOME (backend has the s16 twins),
+//! not the request — an image's identity must describe its bytes, not its intent.
+struct public DlimCpuConfig {
+    backend : string
+    q8_mr : int64
+    q8_wbias : int64
+    q8_kgroup : int64
+    kq_mr4 : int64
+    kq_mr5 : int64
+    kq_mr6 : int64
+    kq_mr40 : int64
+    q51_mr : int64
+    wscale_f16 : bool
+    kquant_native : bool
+    kq_q40_native : bool
+    kq_q50_native : bool
+    kq_q51_native : bool
+}
+
+//! The vulkan flavor's plan inputs, RESOLVED — `coopmat_mode` is the running mode (not the raw
+//! env string), `vram_mb` the concrete budget the plan is computed against. The dense bits and
+//! `cls` are here so every walk-shaping switch is in the identity (the old tag missed them).
+struct public DlimVulkanConfig {
+    coopmat_mode : int
+    expert_q8n : bool
+    vram_mb : int64
+    moe_layers : int64
+    moe_stream : int64
+    dn : bool
+    attn : bool
+    dnd : bool
+    shexp : bool
+    qkv : bool
+    cls : bool
+    dense : bool
+    dense_attn : bool
+    dense_shexp : bool
+    subgroup_size : int
+    max_storage_range : int64
+}
+
+//! The metal flavor's half. Minimal for now — the metal-flavor audit (arc phase G) decides
+//! whether servability needs more than the mode.
+struct public DlimMetalConfig {
+    mode : string
+}
+
+//! The whole bake configuration. `vulkan_on`/`metal_on` are presence flags — a flavor section
+//! whose tier is absent on this box stays zeroed and MUST NOT be read.
+struct public DlimConfiguration {
+    quant : string = "q8"
+    cpu : DlimCpuConfig
+    vulkan_on : bool
+    vulkan : DlimVulkanConfig
+    metal_on : bool
+    metal : DlimMetalConfig
+}
+
+// ===== section sources (tiers register at [init]; config never probes the host itself) =====
+
+[unused_argument(c)]
+def private dlim_no_cpu_source(var c : DlimCpuConfig) {
+    panic("dasLLAMA: no DlimConfiguration cpu source registered (dasllama_common's [init] provides it)")
+}
+
+[unused_argument(c)]
+def private dlim_no_vulkan_source(var c : DlimVulkanConfig) : bool => false
+
+[unused_argument(c)]
+def private dlim_no_metal_source(var c : DlimMetalConfig) : bool => false
+
+var private g_dlim_cpu_source = @@dlim_no_cpu_source
+var private g_dlim_vulkan_source = @@dlim_no_vulkan_source
+var private g_dlim_metal_source = @@dlim_no_metal_source
+
+//! The CPU tier registers its section filler (must run its backend select ONCE before reading
+//! the layout getters — that side effect lives in the source, never in the identity).
+def public set_dlim_cpu_source(f : function<(var c : DlimCpuConfig) : void>) {
+    g_dlim_cpu_source = f
+}
+
+//! A GPU tier registers its section filler; returns false when the tier is absent/unarmed.
+def public set_dlim_vulkan_source(f : function<(var c : DlimVulkanConfig) : bool>) {
+    g_dlim_vulkan_source = f
+}
+
+def public set_dlim_metal_source(f : function<(var c : DlimMetalConfig) : bool>) {
+    g_dlim_metal_source = f
+}
+
+//! Build the configuration this process would bake/load with. The ONE place host state is read.
+def public dlim_config_current(quant : string = "q8") : DlimConfiguration {
+    var c = DlimConfiguration(quant = quant)
+    invoke(g_dlim_cpu_source, c.cpu)
+    c.vulkan_on = invoke(g_dlim_vulkan_source, c.vulkan)
+    c.metal_on = invoke(g_dlim_metal_source, c.metal)
+    return c
+}
+
+// ===== pure formatters (identity, tags, JSON) =====
+
+//! The identity string an image file/header is keyed by — a pure formatter of the struct.
+//! `image_version` comes from the caller (dasllama_image owns the version constant).
+def public dlim_identity(c : DlimConfiguration; image_version : int; tag : string = "") : string {
+    return ("v{image_version}|{c.quant}|{c.cpu.backend}|{c.cpu.wscale_f16 ? "s16" : "s32"}"
+        + "|q8 mr{c.cpu.q8_mr} b{c.cpu.q8_wbias} g{c.cpu.q8_kgroup}"
+        + "|kq {c.cpu.kq_mr4}/{c.cpu.kq_mr5}/{c.cpu.kq_mr6}/{c.cpu.kq_mr40}"
+        + "|q51 mr{c.cpu.q51_mr}"
+        + "|nat {c.cpu.kquant_native ? 1 : 0}{c.cpu.kq_q40_native ? 1 : 0}{c.cpu.kq_q50_native ? 1 : 0}{c.cpu.kq_q51_native ? 1 : 0}"
+        + (tag != "" ? "|{tag}" : ""))
+}
+
+//! The vulkan flavor's identity tag, from the RESOLVED section (the old tag folded raw env
+//! strings, so "auto" hid device-derived byte differences).
+def public dlim_vulkan_tag(v : DlimVulkanConfig) : string {
+    return ("vulkan|m{v.coopmat_mode}{v.expert_q8n ? "n" : ""} b{v.vram_mb}"
+        + " l{v.moe_layers} s{v.moe_stream}"
+        + " r{v.dn ? 1 : 0}{v.attn ? 1 : 0}{v.dnd ? 1 : 0}{v.shexp ? 1 : 0}{v.qkv ? 1 : 0}{v.cls ? 1 : 0}"
+        + "{v.dense ? 1 : 0}{v.dense_attn ? 1 : 0}{v.dense_shexp ? 1 : 0}")
+}
+
+//! Round-trip: the JSON embedded in the image meta and consumed by `dasllama-convert --config`.
+def public dlim_config_json(c : DlimConfiguration) : string => sprint_json(c, true)
+
+// hand-carried config files grow a UTF-8 BOM on Windows editors/tools — tolerate it
+def public dlim_config_from_json(text : string; var c : DlimConfiguration) : bool => (
+    sscan_json(contains_utf8_bom(text) ? slice(text, 3) : text, c))
diff --git a/modules/dasLLAMA/dasllama/dasllama_env.das b/modules/dasLLAMA/dasllama/dasllama_env.das
index 0609e1ac90..0f2f053267 100644
--- a/modules/dasLLAMA/dasllama/dasllama_env.das
+++ b/modules/dasLLAMA/dasllama/dasllama_env.das
@@ -372,6 +372,8 @@ def private reg_test(var o : array<EnvKnob>) {
       "Directory of audio corpus files for the transcription tests.")
     k(o, "TMPDIR", EnvKind.path, EnvArea.test, "/tmp",
       "Scratch directory for test artifacts; set by the OS on macOS.")
+    k(o, "TEMP", EnvKind.path, EnvArea.test, "",
+      "Windows scratch-directory fallback when TMPDIR is unset (the test runner's log dir).")
 }
 
 def private reg_example(var o : array<EnvKnob>) {
diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index 3789d2ec6c..17506c827c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -13,6 +13,8 @@ require daslib/array_boost   // nolint:STYLE030 — temp_array is [template]; ST
 require dasllama/dasllama_common
 require dasllama/dasllama_layout   // convert_model_to_metal_blob — the blob-flavor image transform
 require dasllama/dasllama_math   // active_kernel_backend — half the image identity
+require dasllama/dasllama_config   // DlimConfiguration + dlim_identity — the identity formatter
+require math
 
 // The prepared-model image (spec: fmap-model-image plan, locked 2026-07-16): the post-load
 // Model dumped once — planes POST-repack, page-aligned — then mapped back with zero O(model)
@@ -31,7 +33,7 @@ require dasllama/dasllama_math   // active_kernel_backend — half the image ide
 // config-derived. A loader change that alters which tensors load leaves a structurally VALID stale
 // image that silently represents a different model; only this version catches it. Mismatch
 // regenerates from the gguf, never migrates.
-let IMAGE_VERSION = 6   // v6: glm4moe NextN heads now load (blk.n_layers + its qkv biases)
+let IMAGE_VERSION = 7   // v7: identity string + DlimConfiguration JSON ride the meta head (readable declines; the .dlim-arc format changes batch into this one bump)
 
 //! The metal (blob-only) flavor's identity tag: q8 planes ride the 34B block_q8_0 blob and the
 //! kq scale planes their GPU forms (convert_model_to_metal_blob) — flavors are per-config and
@@ -48,16 +50,11 @@ struct ImgSection {
     bytes : uint64
 }
 
-// the box + knob identity an image is valid for; folded into filename AND header. Must be computed
-// AFTER the same backend select the gguf loader runs at repack time (entry-time default differs).
-// `tag` distinguishes image kinds sharing one source path (e.g. "tower-f32" vs "tower-q8").
+// the box + knob identity an image is valid for; folded into filename AND header. A PURE
+// formatter of DlimConfiguration — the backend-select side effect lives in the config's cpu
+// source, so callers need no ordering ritual. `tag` distinguishes kinds sharing one source path.
 def image_identity(tag : string = "") : string {
-    select_matmul_backend_for_load()
-    return ("v{IMAGE_VERSION}|{active_kernel_backend()}|{get_wscale_f16() ? "s16" : "s32"}"
-        + "|q8 mr{active_q8_layout_mr()} b{active_q8_wbias()} g{active_q8_kgroup()}"
-        + "|kq {active_kq_layout_mr(4)}/{active_kq_layout_mr(5)}/{active_kq_layout_mr(6)}/{active_kq_layout_mr(40)}"
-        + "|q51 mr{active_q51_layout_mr()}"
-        + (tag != "" ? "|{tag}" : ""))
+    return dlim_identity(dlim_config_current(), IMAGE_VERSION, tag)
 }
 
 // the image path for (gguf, current identity) — knob combos coexist as separate files
@@ -361,7 +358,7 @@ def private serialize_image_meta(var arch : Archive; var t : Model) {
     arch |> serialize_raw(t.mtp_headnorm_off)
 }
 
-// the tripwire: serialize_image_meta(Model) covers 64 fields; blocks + image_map +
+// the tripwire: serialize_image_meta(Model) covers 65 fields; blocks + image_map +
 // image_bytes are deliberate skips. A new non-array Model field trips this until BOTH agree.
 let IMAGE_META_FIELDS = 65 + 3
 
@@ -425,6 +422,9 @@ def save_image(var t; path : string; tag : string = "") : bool {
     // per-writer tmp name: concurrent savers (parallel test workers on one cache miss) must
     // not clobber each other's half-written file; last atomic rename wins with same content
     let tmp_path = "{path}.{ref_time_ticks()}.tmp"
+    // one config snapshot serves the meta embed AND the header hash — they must agree
+    let dcfg = dlim_config_current()
+    let ident = dlim_identity(dcfg, IMAGE_VERSION, tag)
     var fend = 0ul
     var meta_off = 0ul
     var meta_bytes = 0ul
@@ -473,9 +473,15 @@ def save_image(var t; path : string; tag : string = "") : bool {
         let direct_mb = int64(unsafe(dwrite_stat(w.h, 2))) >> 20l
         let bounce_mb = int64(unsafe(dwrite_stat(w.h, 3))) >> 20l
         to_log(LOG_INFO, "dasLLAMA image:   writer split: stage {copy_ms}ms ({bounce_mb} MB bounced), syscall {write_ms}ms ({direct_mb} MB direct), unaccounted {planes_ms - copy_ms - write_ms}ms\n")
-        // meta = [sections][the walk's scalar stream], one blob at the tail
+        // meta = [identity string][config JSON][sections][the walk's scalar stream], one blob at
+        // the tail — the two strings lead so a mismatched load can print WHAT the image was
+        // baked for without parsing anything else
         var smeta <- new MemSerializer()
         var sarch = Archive(reading = false, stream = smeta)
+        var m_ident = ident
+        var m_cfg = dlim_config_json(dcfg)
+        sarch |> serialize(m_ident)
+        sarch |> serialize(m_cfg)
         sarch |> serialize(sections)
         var meta_blob <- smeta->extractData()
         meta_blob |> push_from(scalar_blob)
@@ -511,7 +517,7 @@ def save_image(var t; path : string; tag : string = "") : bool {
         store_u64(hdr, 16, meta_off)
         store_u64(hdr, 24, meta_bytes)
         store_u64(hdr, 32, fend)
-        store_u64(hdr, 40, hash(image_identity(tag)))
+        store_u64(hdr, 40, hash(ident))
         ok = false
         fopen(tmp_path, "r+b") $(hf) {
             if (hf != null) {
@@ -608,11 +614,12 @@ def load_image(path : string; var t; tag : string = "") : bool {
         return false
     }
     var bp = unsafe(reinterpret<uint8 const?>(base))
-    if ((read_u32(bp, 0l) != IMAGE_MAGIC || read_u32(bp, 4l) != uint(IMAGE_VERSION)) ||
-            (read_u32(bp, 8l) != uint(IMAGE_PAGE) || read_u64(bp, 40l) != hash(image_identity(tag)))) {
-        // every decline is loud (short of the file simply not existing) — a silently
-        // regenerating cache is undebuggable
-        to_log(LOG_WARNING, "dasLLAMA image: '{path}' declined — size {msize} magic {read_u32(bp, 0l)} version {read_u32(bp, 4l)} (want {IMAGE_VERSION}) page {read_u32(bp, 8l)} identity {read_u64(bp, 40l)} (want {hash(image_identity(tag))} = '{image_identity(tag)}')\n")
+    if (read_u32(bp, 0l) != IMAGE_MAGIC || read_u32(bp, 4l) != uint(IMAGE_VERSION)
+            || read_u32(bp, 8l) != uint(IMAGE_PAGE)) {
+        // every decline is loud (short of a missing file) — a silently regenerating cache is
+        // undebuggable. A wrong version means the meta layout is unknowable, so this arm
+        // cannot read the baked identity string the identity-mismatch arm below prints.
+        to_log(LOG_WARNING, "dasLLAMA image: '{path}' declined — size {msize} magic {read_u32(bp, 0l)} version {read_u32(bp, 4l)} (want {IMAGE_VERSION}) page {read_u32(bp, 8l)}\n")
         unsafe(fmap_close(base, msize))
         return false
     }
@@ -628,6 +635,27 @@ def load_image(path : string; var t; tag : string = "") : bool {
         unsafe(fmap_close(base, msize))
         return false
     }
+    let want_ident = image_identity(tag)
+    if (read_u64(bp, 40l) != hash(want_ident)) {
+        // same version ⇒ the meta head is readable: say WHAT the image was baked for, not
+        // just that a 64-bit hash missed (bounds were validated above)
+        var head : array<uint8>
+        head |> resize(int(min(meta_bytes, 65536ul)))
+        unsafe {
+            memcpy(addr(head[0]), reinterpret<void?>(bp + int64(meta_off)), uint64(long_length(head)))
+        }
+        var hmeta <- new MemSerializer(head)
+        var harch = Archive(reading = true, stream = hmeta)
+        var baked_ident = ""
+        harch |> serialize(baked_ident)
+        to_log(LOG_WARNING, "dasLLAMA image: '{path}' declined — baked for '{hmeta->OK() ? baked_ident : "(unreadable)"}', this run is '{want_ident}'\n")
+        delete head
+        unsafe {
+            delete hmeta
+        }
+        unsafe(fmap_close(base, msize))
+        return false
+    }
     // the meta blob is the ONE copied+parsed piece (small); planes stay lazy in the mapping
     var meta_blob : array<uint8>
     meta_blob |> resize(int(meta_bytes))
@@ -636,6 +664,10 @@ def load_image(path : string; var t; tag : string = "") : bool {
     }
     var meta <- new MemSerializer(meta_blob)
     var rarch = Archive(reading = true, stream = meta)
+    var baked_ident = ""
+    var baked_cfg = ""
+    rarch |> serialize(baked_ident)
+    rarch |> serialize(baked_cfg)
     var sections : array<ImgSection>
     rarch |> serialize(sections)
     // the header count must agree with the meta blob's own section list — a disagreement
diff --git a/modules/dasLLAMA/dasllama/dasllama_math.das b/modules/dasLLAMA/dasllama/dasllama_math.das
index 316c24becb..187a7cc3cd 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math.das
@@ -2119,6 +2119,12 @@ def public gpu_want_qkv : bool
 def public gpu_want_cls : bool
     => env_flag("DASLLAMA_GPU_CLS", false)
 
+//! The classifier UPLOAD gate (opt-OUT, default on when the tier is armed) — distinct from
+//! [[gpu_want_cls]], the opt-IN arm signal. One definition, shared by the upload walk and the
+//! DlimConfiguration identity, so the two can never disagree on the default again.
+def public gpu_want_cls_upload : bool
+    => env_flag("DASLLAMA_GPU_CLS", true)
+
 //! A GPU backend registers its arm probe here at ``[init]`` so config-driven arming works
 //! after module init (the env path arms at ``[init]`` directly).
 def public set_moe_gpu_arm(name : string; f : function<() : bool>) {
diff --git a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
index fc7b11b881..dd044e58f8 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
@@ -6,6 +6,7 @@ module dasllama_math_vulkan shared public
 require dasllama/dasllama_math
 require dasllama/dasllama_gemm_schema  // kq_qsb/kq_ssb + the q8/kq plane consts — the stride source
 require dasllama/dasllama_env  // the shared typed env readers + the knob registry
+require dasllama/dasllama_config  // DlimConfiguration — this module registers the vulkan source
 require dasllama/dasllama_par
 require dasllama/dasllama_vulkan_lens
 require vulkan
@@ -4302,6 +4303,85 @@ def private nonowning_buf(h : uint64) : Buffer {
     return b
 }
 
+// The coopmat-mode ladder, shared by vk_moe_init and the DlimConfiguration source — one
+// resolver, so the config's recorded mode can never drift from the mode the device runs.
+def private resolve_coopmat_mode(has_cm, has_cm2 : bool) : int {
+    // fastest MEASURED default (mm; cm2 opt-in until it beats mm); DASLLAMA_COOPMAT overrides
+    var cmode = has_cm ? 3 : 0
+    if (has_cm) {
+        let mode = env_str("DASLLAMA_COOPMAT", "")
+        if (mode == "sdot4") {
+            cmode = 0
+        } elif (mode == "f16") {
+            cmode = 1
+        } elif (mode == "int8") {
+            cmode = 2
+        } elif (mode == "mm") {
+            cmode = 3
+        } elif (mode == "cm2" && has_cm2) {
+            cmode = 4
+        }
+    }
+    if (g_coopmat_mode_force >= 0) {
+        cmode = has_cm ? g_coopmat_mode_force : 0
+    }
+    if (cmode == 4 && !has_cm2) {
+        cmode = 3   // forced/requested cm2 without the extension: mm
+    }
+    return cmode
+}
+
+struct private VkHeapInfo {
+    budget : int64   // largest device-local heap's current budget (0 = no VK_EXT_memory_budget)
+    used : int64
+    size : int64
+}
+
+def private query_heap_info(phys : VkPhysicalDevice) : VkHeapInfo {
+    var r = VkHeapInfo()
+    if (!device_extension_available(phys, "VK_EXT_memory_budget")) {
+        return r
+    }
+    var mb = VkPhysicalDeviceMemoryBudgetPropertiesEXT()   // sType pre-filled by the ctor
+    var mp2 = VkPhysicalDeviceMemoryProperties2()
+    unsafe {
+        mp2.pNext = addr<void?>(mb)
+    }
+    vkGetPhysicalDeviceMemoryProperties2(phys, mp2)
+    var best = -1
+    for (i in range(int(mp2.memoryProperties.memoryHeapCount))) {
+        if (mp2.memoryProperties.memoryHeaps[i].flags.device_local
+                && (best < 0 || mb.heapBudget[i] > mb.heapBudget[best])) {
+            best = i
+        }
+    }
+    if (best >= 0 && mb.heapBudget[best] > 0ul) {
+        r.budget = int64(mb.heapBudget[best])
+        r.used = int64(mb.heapUsage[best])
+        r.size = int64(mp2.memoryProperties.memoryHeaps[best].size)
+    }
+    return r
+}
+
+// The pre-carve weight cap, shared by vk_moe_init and the DlimConfiguration source. Env wins
+// outright (=0 pins WEIGHT_CAP — the misreporting-driver hatch); auto rounds DOWN to 256 MB so
+// the recorded config (hence the flavor identity) does not churn with heap-budget wiggle.
+def private resolve_weight_cap(heap : VkHeapInfo) : int64 {
+    let vram_mb = gpu_want_vram_mb()
+    if (vram_mb > 0l) {
+        return vram_mb * 1_000_000l
+    }
+    if (has_env_variable("DASLLAMA_GPU_VRAM_MB")) {
+        return WEIGHT_CAP
+    }
+    var cap = WEIGHT_CAP
+    if (heap.budget > 0l) {
+        cap = clamp(heap.budget - VRAM_RESERVE, 0l, cap)
+        cap = cap / 256_000_000l * 256_000_000l
+    }
+    return cap
+}
+
 def private vk_moe_init : bool {
     if (g_init_failed) {   // checked FIRST: a partially-built g_gpu must never report ready
         return false
@@ -4327,28 +4407,7 @@ def private vk_moe_init : bool {
     // coopmat requested whenever supported — the fa twin needs it even in sdot4 GEMM mode
     g_gpu.has_coopmat = cooperative_matrix_supported(g_gpu.phys)
     g_gpu.has_coopmat2 = g_gpu.has_coopmat && cooperative_matrix2_supported(g_gpu.phys)
-    // fastest MEASURED default (mm; cm2 opt-in until it beats mm); DASLLAMA_COOPMAT overrides
-    g_gpu.coopmat_mode = g_gpu.has_coopmat ? 3 : 0
-    if (g_gpu.has_coopmat) {
-        let mode = env_str("DASLLAMA_COOPMAT", "")
-        if (mode == "sdot4") {
-            g_gpu.coopmat_mode = 0
-        } elif (mode == "f16") {
-            g_gpu.coopmat_mode = 1
-        } elif (mode == "int8") {
-            g_gpu.coopmat_mode = 2
-        } elif (mode == "mm") {
-            g_gpu.coopmat_mode = 3
-        } elif (mode == "cm2" && g_gpu.has_coopmat2) {
-            g_gpu.coopmat_mode = 4
-        }
-    }
-    if (g_coopmat_mode_force >= 0) {
-        g_gpu.coopmat_mode = g_gpu.has_coopmat ? g_coopmat_mode_force : 0
-    }
-    if (g_gpu.coopmat_mode == 4 && !g_gpu.has_coopmat2) {
-        g_gpu.coopmat_mode = 3   // forced/requested cm2 without the extension: mm
-    }
+    g_gpu.coopmat_mode = resolve_coopmat_mode(g_gpu.has_coopmat, g_gpu.has_coopmat2)
     // dedicated transfer family: streamed copies overlap compute (DASLLAMA_VK_XFERQ=0 = bisect hatch)
     var xfam = -1
     if (g_gpu.has_coopmat && env_flag("DASLLAMA_VK_XFERQ", true)
@@ -4405,38 +4464,17 @@ def private vk_moe_init : bool {
         return false
     }
     g_gpu.rows_per_wg = int64((WG_X + sg - 1u) / sg)   // = gl_NumSubgroups for our 1D workgroup
-    // env wins outright (=0 pins WEIGHT_CAP — the misreporting-driver hatch); else live budget - reserve
-    g_gpu.weight_budget = WEIGHT_CAP
-    let vram_mb = gpu_want_vram_mb()
-    let vram_override = vram_mb > 0l || has_env_variable("DASLLAMA_GPU_VRAM_MB")
-    if (vram_mb > 0l) {
-        g_gpu.weight_budget = vram_mb * 1_000_000l
-    }
-    if (device_extension_available(g_gpu.phys, "VK_EXT_memory_budget")) {
-        var mb = VkPhysicalDeviceMemoryBudgetPropertiesEXT()   // sType pre-filled by the ctor
-        var mp2 = VkPhysicalDeviceMemoryProperties2()
-        unsafe {
-            mp2.pNext = addr<void?>(mb)
-        }
-        vkGetPhysicalDeviceMemoryProperties2(g_gpu.phys, mp2)
-        var best = -1
-        for (i in range(int(mp2.memoryProperties.memoryHeapCount))) {
-            if (mp2.memoryProperties.memoryHeaps[i].flags.device_local
-                    && (best < 0 || mb.heapBudget[i] > mb.heapBudget[best])) {
-                best = i
-            }
-        }
-        if (best >= 0 && mb.heapBudget[best] > 0ul) {
-            let safe_cap = max(int64(mb.heapBudget[best]) - VRAM_RESERVE, 0l)
-            // the honest cliff leaves 2GB of the raw heap for the desktop (6000MB healthy, 6803 demoted)
-            let cliff = min(safe_cap, int64(mp2.memoryProperties.memoryHeaps[best].size) - 2_147_483_648l)
-            if (!vram_override) {
-                g_gpu.weight_budget = min(safe_cap, g_gpu.weight_budget)
-            } elif (g_gpu.weight_budget > cliff) {
-                to_log(LOG_WARNING, "dasLLAMA vulkan tier: DASLLAMA_GPU_VRAM_MB {g_gpu.weight_budget / 1000000l} MB is above the demotion cliff — WDDM will silently demote buffers to SysMem (act-role collapse); lower it to <= {cliff / 1000000l} MB\n")
-            }
-            to_log(LOG_INFO, "dasLLAMA vulkan tier: device heap budget {int64(mb.heapBudget[best]) / 1000000l} MB (used {int64(mb.heapUsage[best]) / 1000000l}), weight cap {g_gpu.weight_budget / 1000000l} MB\n")
-        }
+    // env-vs-auto resolution shared with the DlimConfiguration source (resolve_weight_cap)
+    let heap = query_heap_info(g_gpu.phys)
+    g_gpu.weight_budget = resolve_weight_cap(heap)
+    if (heap.budget > 0l) {
+        let vram_override = gpu_want_vram_mb() > 0l || has_env_variable("DASLLAMA_GPU_VRAM_MB")
+        // the honest cliff leaves 2GB of the raw heap for the desktop (6000MB healthy, 6803 demoted)
+        let cliff = clamp(heap.budget - VRAM_RESERVE, 0l, heap.size - 2_147_483_648l)
+        if (vram_override && g_gpu.weight_budget > cliff) {
+            to_log(LOG_WARNING, "dasLLAMA vulkan tier: DASLLAMA_GPU_VRAM_MB {g_gpu.weight_budget / 1000000l} MB is above the demotion cliff — WDDM will silently demote buffers to SysMem (act-role collapse); lower it to <= {cliff / 1000000l} MB\n")
+        }
+        to_log(LOG_INFO, "dasLLAMA vulkan tier: device heap budget {heap.budget / 1000000l} MB (used {heap.used / 1000000l}), weight cap {g_gpu.weight_budget / 1000000l} MB\n")
     }
     // stream-slot carve: exact loader-reported need, else the legacy constant (direct-upload paths)
     if (gpu_want_moe_stream() != 0l) {
@@ -8886,18 +8924,54 @@ def vulkan_moe_gpu_arm : bool {
     return true
 }
 
-// the vulkan flavor's config identity. ENV-OR-AUTO knobs only — resolving them (vk_moe_init)
-// would carve the stream reserve BEFORE the loader reports the model's slot need (518ae164a);
-// "auto" resolves deterministically per box and the image is local, so the identity is stable.
-def private vk_bake_tag : string {
+// Fill the caps-derived half of the vulkan config section from a physical device. Phys-level
+// queries only — vk_moe_init stays untouched, so the stream-reserve carve still happens AFTER
+// the loader reports the model's slot need (518ae164a).
+def private vk_caps_fill(phys : VkPhysicalDevice; var v : DlimVulkanConfig) {
+    let has_cm = cooperative_matrix_supported(phys)
+    let has_cm2 = has_cm && cooperative_matrix2_supported(phys)
+    v.coopmat_mode = resolve_coopmat_mode(has_cm, has_cm2)
+    v.expert_q8n = v.coopmat_mode == 4
+    v.subgroup_size = int(subgroup_properties(phys).subgroupSize)
+    var props : VkPhysicalDeviceProperties
+    vkGetPhysicalDeviceProperties(phys, props)
+    v.max_storage_range = int64(props.limits.maxStorageBufferRange)
+    v.vram_mb = resolve_weight_cap(query_heap_info(phys)) / 1_000_000l
+}
+
+// The DlimConfiguration vulkan source — RESOLVED values (the old tag folded raw env strings,
+// so "auto" hid device-derived byte differences and a moving heap budget).
+def private vk_dlim_source(var v : DlimVulkanConfig) : bool {
     if (!vulkan_moe_gpu_arm()) {
+        return false
+    }
+    v.moe_layers = gpu_want_moe_layers()
+    v.moe_stream = gpu_want_moe_stream()
+    v.dn = gpu_want_dn()
+    v.attn = gpu_want_attn()
+    v.dnd = gpu_want_dnd()
+    v.shexp = gpu_want_shexp()
+    v.qkv = gpu_want_qkv()
+    v.cls = gpu_want_cls_upload()   // the WALK's gate, not the arm-intent (they had split defaults)
+    v.dense = gpu_want_dense()
+    v.dense_attn = gpu_want_dense_attn()
+    v.dense_shexp = gpu_want_dense_shexp()
+    if (g_gpu != null) {
+        vk_caps_fill(g_gpu.phys, v)
+    } else {
+        var inscope instance <- create_instance("dasLLAMA dlim config", make_api_version(1u, 3u, 0u))
+        volkLoadInstance(boost_value_to_vk(instance))
+        vk_caps_fill(select_physical_device(instance), v)
+    }
+    return true
+}
+
+def private vk_bake_tag : string {
+    var v : DlimVulkanConfig
+    if (!vk_dlim_source(v)) {
         return ""
     }
-    let cm = env_str("DASLLAMA_COOPMAT", "auto")
-    let vb = env_str("DASLLAMA_GPU_VRAM_MB", "auto")
-    return ("m{cm} b{vb}"
-        + " l{gpu_want_moe_layers()} s{gpu_want_moe_stream()}"
-        + " r{gpu_want_dn() ? 1 : 0}{gpu_want_attn() ? 1 : 0}{gpu_want_dnd() ? 1 : 0}{gpu_want_shexp() ? 1 : 0}{gpu_want_qkv() ? 1 : 0}{gpu_want_cls() ? 1 : 0}")
+    return dlim_vulkan_tag(v)
 }
 
 [init]
@@ -8907,6 +8981,7 @@ def dasllama_math_vulkan_register() {
         needs_repack = false, priority = -1, available = @@vulkan_backend_available))
     set_moe_gpu_arm("vulkan", @@vulkan_moe_gpu_arm)
     set_moe_gpu_bake_tag(@@vk_bake_tag)
+    set_dlim_vulkan_source(@@vk_dlim_source)
     set_moe_gpu_vram_report(@@vk_resident_bytes)
     set_moe_gpu_device_report(@@vk_device_name)
     set_moe_gpu_budget_hooks(@@vk_weight_budget, @@vk_plane_bytes)
diff --git a/modules/dasLLAMA/tests/run.das b/modules/dasLLAMA/tests/run.das
index c0f45570ba..d34741065b 100644
--- a/modules/dasLLAMA/tests/run.das
+++ b/modules/dasLLAMA/tests/run.das
@@ -34,8 +34,8 @@ struct RunArgs {
     @clarg_doc = "Repeat count — explicit only (default 1, never best-of-N)"
     nreps : int = 1
 
-    @clarg_doc = "daslang binary (default ./bin/daslang — run from the repo root)"
-    das : string = "./bin/daslang"
+    @clarg_doc = "daslang binary (default: the binary running this script — a hardcoded ./bin/daslang picked up a STALE top-level exe on the MSVC layout)"
+    das : string = ""
 
     @clarg_short = "?"
     @clarg_name = "show-help"
@@ -117,23 +117,41 @@ def main() : int {
         to_log(LOG_ERROR, "unknown --suite '{cfg.suite}' (decode | prefill | matrix | kernels | image | all)\n")
         return 2
     }
-    let tmp = empty(get_env_variable("TMPDIR")) ? "/tmp" : get_env_variable("TMPDIR")
+    var tmp = get_env_variable("TMPDIR")
+    if (empty(tmp)) {
+        tmp = get_env_variable("TEMP")   // the Windows spelling; TMPDIR is the POSIX one
+    }
+    if (empty(tmp)) {
+        tmp = "/tmp"
+    }
     // CPU_PREFILL: the suites' CPU truth halves and parity controls prefill on the CPU by intent.
     // HAZARD_STRICT: the scheduling-unification ratchet's runtime half — an undeclared dispatch
     // on an armed hazard oracle PANICS here, so declaration gaps can never ship quietly.
-    var envs = (cfg.full ? "DASLLAMA_PARITY_FULL=1" : "DASLLAMA_TEST_ARMS='{cfg.arm}'") + " DASLLAMA_CPU_PREFILL=1 DASLLAMA_METAL_HAZARD_STRICT=1"
-    if (!empty(cfg.family)) {   // composes with either mode: a family-scoped full gate is the profiling-cadence default
-        envs = "{envs} DASLLAMA_TEST_FAMILY='{cfg.family}'"
+    // cmd.exe has no VAR=val prefix — `set "VAR=val"&&` is the safe form (llvm_tune's tuner_cmd)
+    let win = get_platform_name() == "windows"
+    var envs = ""
+    if (win) {
+        envs = ((cfg.full ? "set \"DASLLAMA_PARITY_FULL=1\"&& " : "set \"DASLLAMA_TEST_ARMS={cfg.arm}\"&& ")
+            + "set \"DASLLAMA_CPU_PREFILL=1\"&& set \"DASLLAMA_METAL_HAZARD_STRICT=1\"&& ")
+        if (!empty(cfg.family)) {   // composes with either mode: a family-scoped full gate is the profiling-cadence default
+            envs = "{envs}set \"DASLLAMA_TEST_FAMILY={cfg.family}\"&& "
+        }
+    } else {
+        envs = (cfg.full ? "DASLLAMA_PARITY_FULL=1" : "DASLLAMA_TEST_ARMS='{cfg.arm}'") + " DASLLAMA_CPU_PREFILL=1 DASLLAMA_METAL_HAZARD_STRICT=1 "
+        if (!empty(cfg.family)) {
+            envs = "DASLLAMA_TEST_FAMILY='{cfg.family}' {envs}"
+        }
     }
     // the full gate holds the 8B/70B tails — the stock 1200s dastest wall is an arm-mode budget
     let tmo = cfg.full ? 3600 : 1200
     let reps = max(cfg.nreps, 1)
+    let das_exe = empty(cfg.das) ? get_command_line_arguments()[0] : cfg.das
     var failures = 0
     for (rep in range(reps)) {
         for (file in files) {
             let tag = base_name(file)
             let log_path = path_join(tmp, "dasllama_run_{tag}_{rep}_{ref_time_ticks()}.log")
-            let cmd = "{envs} \"{cfg.das}\" -jit dastest/dastest.das -- --test \"{file}\" --timeout {tmo} > \"{log_path}\" 2>&1"
+            let cmd = "{envs}\"{das_exe}\" -jit dastest/dastest.das -- --test \"{file}\" --timeout {tmo} > \"{log_path}\" 2>&1"
             let rep_tag = reps > 1 ? " rep {rep + 1}/{reps}" : ""
             to_log(LOG_INFO, "START {tag}{rep_tag}: {cmd}\n")
             let t0 = ref_time_ticks()
diff --git a/modules/dasLLAMA/tests/test_env_registry.das b/modules/dasLLAMA/tests/test_env_registry.das
index 99a2768135..bed2bd1727 100644
--- a/modules/dasLLAMA/tests/test_env_registry.das
+++ b/modules/dasLLAMA/tests/test_env_registry.das
@@ -17,6 +17,7 @@ require daslib/strings_boost
 let SCAN_ROOTS = [
     "modules/dasLLAMA",
     "utils/dasllama-server",
+    "utils/dasllama-convert",
     "examples/dasLLAMA",
     "tutorials/dasLLAMA"
 ]
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 3fc040a4d6..56710c43f5 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -10,6 +10,11 @@ options stack = 65536   // dasLLAMA program-root convention (options stack does
 // this ahead of time and the first real load maps instead of converting. `--flavor` picks which
 // image a config with several flavors emits (planar CPU, metal blob, vulkan-baked).
 //
+// The config is EXPLICIT (DlimConfiguration): `--dump-config` prints/writes this box's config as
+// JSON; `--config x.json` bakes against a supplied one — applied knob-by-knob, then verified
+// fail-closed against the resulting identity, so a knob that did not take is an error, never a
+// silently different image.
+//
 // Conversion is I/O bound at both ends: the transcode is ~5% of wall time, the rest is reading the
 // GGUF and writing the image. Both numbers are reported per stage so a slow box is diagnosable
 // without a profiler.
@@ -18,6 +23,7 @@ require dasllama/dasllama_transformer   // nolint:STYLE029 — umbrella fires ea
 require dasllama/dasllama_math          // apply_box_profile_runtime + select_matmul_backend_for_load
 require dasllama/dasllama_image         // the .dlim rail itself
 require dasllama/dasllama_layout        // convert_model_to_metal_blob — the metal flavor's transform
+require dasllama/dasllama_config        // DlimConfiguration — --config / --dump-config
 require daslib/clargs
 require daslib/jobque_boost
 require daslib/fio
@@ -51,6 +57,12 @@ struct ConvertArgs {
     @clarg_doc = "Which image flavor to emit (default: planar)"
     flavor : Flavor = Flavor.planar
 
+    @clarg_doc = "Path to a DlimConfiguration JSON (from --dump-config on the target box) to bake against"
+    config : string
+
+    @clarg_doc = "Print this box's DlimConfiguration JSON (or write it to -o) and exit"
+    dump_config : bool
+
     @clarg_doc = "Convert even if a valid image is already there (default: report it and exit 0)"
     force : bool
 
@@ -94,6 +106,21 @@ def private sweep_stale_tmp(gguf : string) : int {
     return n
 }
 
+// q is a REFERENCE — a plain `var q : QuantMode` is a workhorse-type copy and the caller
+// would never see the write (LINT003 caught exactly that)
+def private quant_from_string(s : string; var q : QuantMode&) : bool {
+    if (s == "fp32") {
+        q = QuantMode.fp32
+    } elif (s == "q8") {
+        q = QuantMode.q8
+    } elif (s == "q4_0") {
+        q = QuantMode.q4_0
+    } else {
+        return false
+    }
+    return true
+}
+
 def private flavor_tag(f : Flavor) : string {
     if (f == Flavor.metal) {
         return METAL_IMAGE_TAG
@@ -121,6 +148,32 @@ def main() : int {
         print_help(get_command_info(type<ConvertArgs>), "dasllama-convert")
         return 0
     }
+    if (cfg.dump_config) {
+        // same ordering the load path uses: the sidecar's backend pin precedes the identity
+        apply_box_profile_runtime()
+        let dc = dlim_config_current("{cfg.quant}")
+        let js = dlim_config_json(dc)
+        var rc0 = 0
+        if (cfg.out != "") {
+            var wrote = false
+            fopen(cfg.out, "wb") $(f) {
+                if (f != null) {
+                    f |> fwrite(js)
+                    wrote = true
+                }
+            }
+            if (wrote) {
+                to_log(LOG_INFO, "dasllama-convert: config -> {cfg.out}\n")
+            } else {
+                to_log(LOG_ERROR, "dasllama-convert: cannot write '{cfg.out}'\n")
+                rc0 = 1
+            }
+        } else {
+            print("{js}\n")
+        }
+        to_log(LOG_INFO, "dasllama-convert: identity {dlim_identity(dc, IMAGE_VERSION)}\n")
+        return rc0
+    }
     if (cfg.model == "") {
         to_log(LOG_ERROR, "dasllama-convert: --model is required\n\n")
         print_help(get_command_info(type<ConvertArgs>), "dasllama-convert")
@@ -136,6 +189,42 @@ def main() : int {
     }
     // the backend pin must precede the identity: image_identity names the active kernel backend
     apply_box_profile_runtime()
+    var qm = cfg.quant
+    if (cfg.config != "") {
+        var text = ""
+        fopen(cfg.config, "rb") $(f) {
+            if (f != null) {
+                text = fread(f)
+            }
+        }
+        if (text == "") {
+            to_log(LOG_ERROR, "dasllama-convert: cannot read --config '{cfg.config}'\n")
+            return 2
+        }
+        var want = DlimConfiguration()
+        if (!dlim_config_from_json(text, want)) {
+            to_log(LOG_ERROR, "dasllama-convert: --config '{cfg.config}' is not a DlimConfiguration JSON\n")
+            return 2
+        }
+        if (!quant_from_string(want.quant, qm)) {
+            to_log(LOG_ERROR, "dasllama-convert: --config quant '{want.quant}' is not a QuantMode\n")
+            return 2
+        }
+        // apply what a host can take, then verify FAIL-CLOSED: any knob that did not take
+        // (unavailable backend, missing s16 twins) shows up as an identity mismatch below
+        set_wscale_f16(want.cpu.wscale_f16)
+        set_kquant_native(want.cpu.kquant_native)
+        set_kq_q40_native(want.cpu.kq_q40_native)
+        set_kq_q50_native(want.cpu.kq_q50_native)
+        set_kq_q51_native(want.cpu.kq_q51_native)
+        pin_kernel_backend(want.cpu.backend)
+        let want_ident = dlim_identity(want, IMAGE_VERSION)
+        let have_ident = dlim_identity(dlim_config_current(want.quant), IMAGE_VERSION)
+        if (have_ident != want_ident) {
+            to_log(LOG_ERROR, "dasllama-convert: --config could not be fully applied on this host (cross-box backend targeting lands later in the arc):\n  want {want_ident}\n  have {have_ident}\n")
+            return 2
+        }
+    }
     let tag = flavor_tag(cfg.flavor)
     let out = cfg.out != "" ? cfg.out : image_path_for(cfg.model, tag)
     to_log(LOG_INFO, "dasllama-convert: {cfg.model}\n")
@@ -154,7 +243,7 @@ def main() : int {
     let ts = ref_time_ticks()
     // the job que carries the transcode/repack passes; the load spins its own if we do not
     with_job_que() {
-        var m <- load_model_(cfg.model, cfg.quant)
+        var m <- load_model_(cfg.model, qm)
         let ts_load = ref_time_ticks()
         if (cfg.flavor == Flavor.metal) {
             if (!metal_model_servable(m) || !convert_model_to_metal_blob(m)) {

From 26503273337c86fe4ba73789bc61c8838c665e7a Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 21:26:44 -0700
Subject: [PATCH 04/30] =?UTF-8?q?dlim=20config:=20auto=20vram=20derives=20?=
 =?UTF-8?q?from=20heap=20SIZE,=20not=20the=20live=20budget=20=E2=80=94=20d?=
 =?UTF-8?q?rop=20the=20256=20MB=20rounding?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Boris's catch: no hardware works in 256 MB steps — the rounding existed only to stabilize a
number that fluctuates by construction. Heap SIZE is the hardware constant, so auto resolves
identically every run with no rounding at all; WEIGHT_CAP (4.2 GB) dominates on any card
>= ~5 GB anyway, so auto is a constant 4200 MB on real boxes. Transient VRAM pressure is the
memprio shield's job now, not the budget's; explicit DASLLAMA_GPU_VRAM_MB is untouched.
query_heap_info also fills size without VK_EXT_memory_budget (size needs no extension; only
budget/usage do — heaps rank by live budget when the ext reports it, by raw size otherwise).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 .../dasllama/dasllama_math_vulkan.das         | 38 +++++++++++--------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
index dd044e58f8..87d944168d 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
@@ -4339,33 +4339,42 @@ struct private VkHeapInfo {
 
 def private query_heap_info(phys : VkPhysicalDevice) : VkHeapInfo {
     var r = VkHeapInfo()
-    if (!device_extension_available(phys, "VK_EXT_memory_budget")) {
-        return r
-    }
+    // heap SIZE needs no extension — only the live budget/usage ride VK_EXT_memory_budget
+    let has_budget = device_extension_available(phys, "VK_EXT_memory_budget")
     var mb = VkPhysicalDeviceMemoryBudgetPropertiesEXT()   // sType pre-filled by the ctor
     var mp2 = VkPhysicalDeviceMemoryProperties2()
-    unsafe {
-        mp2.pNext = addr<void?>(mb)
+    if (has_budget) {
+        unsafe {
+            mp2.pNext = addr<void?>(mb)
+        }
     }
     vkGetPhysicalDeviceMemoryProperties2(phys, mp2)
     var best = -1
     for (i in range(int(mp2.memoryProperties.memoryHeapCount))) {
-        if (mp2.memoryProperties.memoryHeaps[i].flags.device_local
-                && (best < 0 || mb.heapBudget[i] > mb.heapBudget[best])) {
+        if (!mp2.memoryProperties.memoryHeaps[i].flags.device_local) {
+            continue
+        }
+        // rank by live budget when the ext reports it, by raw size otherwise
+        if (best < 0) {
+            best = i
+        } elif (has_budget ? mb.heapBudget[i] > mb.heapBudget[best]
+                : mp2.memoryProperties.memoryHeaps[i].size > mp2.memoryProperties.memoryHeaps[best].size) {
             best = i
         }
     }
-    if (best >= 0 && mb.heapBudget[best] > 0ul) {
-        r.budget = int64(mb.heapBudget[best])
-        r.used = int64(mb.heapUsage[best])
+    if (best >= 0) {
         r.size = int64(mp2.memoryProperties.memoryHeaps[best].size)
+        if (has_budget && mb.heapBudget[best] > 0ul) {
+            r.budget = int64(mb.heapBudget[best])
+            r.used = int64(mb.heapUsage[best])
+        }
     }
     return r
 }
 
 // The pre-carve weight cap, shared by vk_moe_init and the DlimConfiguration source. Env wins
-// outright (=0 pins WEIGHT_CAP — the misreporting-driver hatch); auto rounds DOWN to 256 MB so
-// the recorded config (hence the flavor identity) does not churn with heap-budget wiggle.
+// outright (=0 pins WEIGHT_CAP — the misreporting-driver hatch); auto derives from heap SIZE, a
+// hardware constant — same number every run. Transient pressure is the memprio shield's job.
 def private resolve_weight_cap(heap : VkHeapInfo) : int64 {
     let vram_mb = gpu_want_vram_mb()
     if (vram_mb > 0l) {
@@ -4375,9 +4384,8 @@ def private resolve_weight_cap(heap : VkHeapInfo) : int64 {
         return WEIGHT_CAP
     }
     var cap = WEIGHT_CAP
-    if (heap.budget > 0l) {
-        cap = clamp(heap.budget - VRAM_RESERVE, 0l, cap)
-        cap = cap / 256_000_000l * 256_000_000l
+    if (heap.size > 0l) {
+        cap = clamp(heap.size - VRAM_RESERVE, 0l, cap)
     }
     return cap
 }

From 47cd96b8578c5a64e0dcc65041fe13e212319def Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 22:18:33 -0700
Subject: [PATCH 05/30] =?UTF-8?q?dlim=20arc=20phase=20B:=20offline=20vulka?=
 =?UTF-8?q?n=20bake=20=E2=80=94=20dry=20tier,=20role-annotated=20plan,=20b?=
 =?UTF-8?q?yte-identical=20to=20live?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The vulkan flavor now bakes OFFLINE: `dasllama-convert -f vulkan` runs the real GPU upload walk
with a DRY tier — the SAME accept/refuse arithmetic (budget, MAX_STACKS, arena shard cap, rdec
guards) against DlimVulkanConfig's numbers, with every device call gated off (no instance, no
device, no VRAM). vk_moe_init grows a dry branch fed by vulkan_dry_bake_arm (seam:
set_moe_gpu_dry_bake_arm in dasllama_math, so the converter stays vulkan-agnostic); the arm
fail-closes when the config disagrees with the process' env wants (prints both tags).
maxStorageBufferRange moved to init-time capture (g_gpu.msr — config-supplied when dry).

GATE PASSED: offline bake is BYTE-IDENTICAL to the in-process live bake — Qwen3-4B Q4_K_M at
budget 6000, both 4856 MB, same SHA256 (69cf07f2…f0f1). The dry image then MAPPED on a live
GPU-armed load and the walk consumed the baked plan exactly (no divergence warnings).

VkPlanEntry grows `role` (VkBakeRole: cls/dense/shexp/dn/attn/qkv/expert/expert_stream/arena) —
the walk declares its stage via vulkan_bake_role, the slice path verifies it per entry, and P3's
trim will key on it. Collect moved AFTER the upload/placement verdict (was BEFORE, so refused
uploads left phantom plan entries whose validity depended on the device reproducing its budget
verdicts — the old B4 hazard). This fixes the old `-f vulkan`, which did a FULL live VRAM upload
and then wrote an image with empty vkblob/vkplan.

Also: the doubled "vulkan|vulkan|" identity prefix (both load_model_cached branches + the
converter prepended what dlim_vulkan_tag already carries).

Gates: parity SHA256 (above); slice-load parity probe; image mechanics+smol arms 9/9;
lint+format clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_common.das |  54 +++++-
 modules/dasLLAMA/dasllama/dasllama_image.das  |   4 +-
 modules/dasLLAMA/dasllama/dasllama_math.das   |  16 ++
 .../dasllama/dasllama_math_vulkan.das         | 177 +++++++++++++-----
 utils/dasllama-convert/main.das               |  35 +++-
 5 files changed, 232 insertions(+), 54 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index fc9e6950d4..a242889881 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -389,8 +389,11 @@ def private repack_q51_stacks(var t : Model) {
 // flavor load's walk skips the transforms and copies the mapped blob back, plan-checked.
 
 //! One baked gather of the vulkan flavor's plan — walk order, offsets into Model.vkblob.
+//! `role` records WHICH walk stage produced it (VkBakeRole) — the trim pass (P3) and the
+//! slice verifier both key on it.
 struct VkPlanEntry {
     fmt : int
+    role : int
     woff : int64
     n : int64
     rows : int64
@@ -400,6 +403,20 @@ struct VkPlanEntry {
     ws_bytes : int64
 }
 
+//! The upload-walk stage a baked gather belongs to — set by the walk, stamped per entry.
+enum VkBakeRole {
+    none
+    cls
+    dense
+    shexp
+    dn
+    attn
+    qkv
+    expert          //!< resident expert stack (VRAM)
+    expert_stream   //!< streamed expert stack (pinned mirror; CPU planes stay — decode runs there)
+    arena           //!< resident-driver arena plane (dense models)
+}
+
 enum private VkBakeMode {
     off
     collect
@@ -410,10 +427,17 @@ var private g_vk_bake = VkBakeMode.off
 var private g_vk_bake_blob : array<uint8>
 var private g_vk_bake_plan : array<VkPlanEntry>
 var private g_vk_bake_cursor = 0l
+var private g_vk_bake_role = VkBakeRole.none
+
+//! The upload walk declares its current stage here (collect stamps it, slice verifies it).
+def vulkan_bake_role(r : VkBakeRole) {
+    g_vk_bake_role = r
+}
 
 //! Arm collection for the next model load's GPU walk (the vulkan-flavor bake).
 def vulkan_bake_begin {
     g_vk_bake = VkBakeMode.collect
+    g_vk_bake_role = VkBakeRole.none
     g_vk_bake_blob |> clear()
     g_vk_bake_plan |> clear()
 }
@@ -433,6 +457,7 @@ def vulkan_bake_take(var t : Model) : bool {
 //! Arm slicing for a mapped vulkan-flavor load: the walk reads t.vkblob instead of gathering.
 def vulkan_bake_slice_begin {
     g_vk_bake = VkBakeMode.slice
+    g_vk_bake_role = VkBakeRole.none
     g_vk_bake_cursor = 0l
 }
 
@@ -470,11 +495,13 @@ def private vk_bake_append(a : array<uint8>) : int64 {
     return off
 }
 
+// Called AFTER the tier accepted the upload/placement (a refused gather must not enter the
+// plan — the slice path would replay the refusal's absence and diverge).
 def private vk_bake_collect(fmt : int; woff, n, rows : int64; wq, ws : array<uint8>) {
     if (g_vk_bake != VkBakeMode.collect) {
         return
     }
-    var e = VkPlanEntry(fmt = fmt, woff = woff, n = n, rows = rows,
+    var e = VkPlanEntry(fmt = fmt, role = int(g_vk_bake_role), woff = woff, n = n, rows = rows,
                         wq_bytes = long_length(wq), ws_bytes = long_length(ws))
     e.wq_off = vk_bake_append(wq)
     e.ws_off = vk_bake_append(ws)
@@ -493,8 +520,8 @@ def private vk_bake_slice(t : Model; fmt : int; woff, n, rows : int64;
         return false
     }
     let e = t.vkplan[int(g_vk_bake_cursor)]
-    if (e.fmt != fmt || e.woff != woff || e.n != n || e.rows != rows) {
-        to_log(LOG_WARNING, "dasLLAMA vulkan image: baked gather {g_vk_bake_cursor} is (fmt {e.fmt} woff {e.woff} {e.n}x{e.rows}), the walk wants (fmt {fmt} woff {woff} {n}x{rows}) — regathering live from here\n")
+    if (e.fmt != fmt || e.woff != woff || e.n != n || e.rows != rows || e.role != int(g_vk_bake_role)) {
+        to_log(LOG_WARNING, "dasLLAMA vulkan image: baked gather {g_vk_bake_cursor} is (fmt {e.fmt} role {e.role} woff {e.woff} {e.n}x{e.rows}), the walk wants (fmt {fmt} role {int(g_vk_bake_role)} woff {woff} {n}x{rows}) — regathering live from here\n")
         g_vk_bake = VkBakeMode.off
         return false
     }
@@ -523,7 +550,6 @@ def private moe_gpu_gather_stack(t : Model; woff : int64; n, rows, slice_rows :
         return
     }
     invoke(g_layout_gather, t, woff, n, rows, slice_rows, mr, kgroup, wbias, wq, ws)
-    vk_bake_collect(0, woff, n, rows, wq, ws)
 }
 
 def private moe_gpu_gather_stack_kq(t : Model; fmt : KqFmt; woff : int64; n, rows, slice_rows : int64;
@@ -533,7 +559,6 @@ def private moe_gpu_gather_stack_kq(t : Model; fmt : KqFmt; woff : int64; n, row
         return
     }
     invoke(g_layout_gather_kq, t, fmt, woff, n, rows, slice_rows, repacked, mr, wq, ws)
-    vk_bake_collect(int(fmt), woff, n, rows, wq, ws)
 }
 
 def private moe_gpu_gather_stack_q8n(t : Model; woff : int64; n, rows, slice_rows : int64;
@@ -544,7 +569,6 @@ def private moe_gpu_gather_stack_q8n(t : Model; woff : int64; n, rows, slice_row
         return
     }
     invoke(g_layout_gather_q8n, t, woff, n, rows, slice_rows, mr, kgroup, wbias, wq)
-    vk_bake_collect(6, woff, n, rows, wq, no_ws)
 }
 
 def register_batch_decode_override(name : string; fn : BatchDecodeOverrideFn) {
@@ -2095,7 +2119,11 @@ def private moe_gpu_gather_upload(t : Model; f : KqFmt; woff : int64; n, rows, s
             : (f == KqFmt.k6 ? t.kq_repack_mr6 : t.kq_repack_mr40))) : 1l
         moe_gpu_gather_stack_kq(t, f, woff, n, rows, slice_rows, t.kq_repacked, kmr, wq, ws)
     }
-    return moe_gpu_upload_stack(wq, ws, woff, n, rows, int(f), stream)
+    let ok = moe_gpu_upload_stack(wq, ws, woff, n, rows, int(f), stream)
+    if (ok) {
+        vk_bake_collect(int(f), woff, n, rows, wq, ws)
+    }
+    return ok
 }
 
 //! What a whole-model resident load would cost on the device. The resident driver is all-or-nothing
@@ -2225,6 +2253,9 @@ def private resident_place(t : Model; f : KqFmt; woff : int64; n, rows : int64;
         moe_gpu_gather_stack_kq(t, f, woff, n, rows, rows, t.kq_repacked, kmr, wq, ws)
     }
     let blk = rdec_place(wq, ws, n, rows, int(f))
+    if (blk >= 0l) {
+        vk_bake_collect(int(f), woff, n, rows, wq, ws)
+    }
     delete wq
     delete ws
     return blk
@@ -2259,6 +2290,7 @@ def private resident_layer_fmts(t : Model; l : int64) : tuple<fq : KqFmt; fk : K
 //! leaves the driver unarmed) if the model is not a servable dense shape or does not fit at seq_cap.
 def resident_upload(t : Model; seq_cap : int64) : bool {
     g_rdec_active = false
+    vulkan_bake_role(VkBakeRole.arena)
     if (!moe_gpu_resident_installed() || t.quant != QuantMode.q8 || t.config.n_expert > 0l) {
         return false
     }
@@ -2801,6 +2833,7 @@ def moe_gpu_upload_resident(t : Model) {
     // DASLLAMA_GPU_CLS=0 keeps it on the CPU (A/B lever).
     let cls_fmt = t.config.shared_weights ? t.emb_fmt : t.wcls_fmt
     let cls_servable = cls_fmt == KqFmt.q8 ? (t.cls_q8 || !t.config.shared_weights) : moe_gpu_fmt_kq(cls_fmt)
+    vulkan_bake_role(VkBakeRole.cls)
     if (cls_servable && gpu_want_cls_upload()
             && moe_gpu_gather_upload(t, cls_fmt, t.wcls_off, dim, t.config.vocab_size, t.config.vocab_size, mr, kgroup, wbias, wq, ws)) {
         set_moe_gpu_cls_off(t.wcls_off)
@@ -2808,6 +2841,7 @@ def moe_gpu_upload_resident(t : Model) {
     // dense (attention-side) planes second — DASLLAMA_GPU_DENSE=1 / gpu_dense opt-in. Arch-agnostic:
     // recurrent layers carry the deltanet triple, attention layers the q/o pair (k/v stay CPU — small).
     // Layer-ascending; each successful upload marks its plane, a budget stop ends the walk.
+    vulkan_bake_role(VkBakeRole.dense)
     if (gpu_want_dense()) {
         var dense_marked = 0l
         var dense_stop = false
@@ -2856,6 +2890,7 @@ def moe_gpu_upload_resident(t : Model) {
     }
     // shared-expert triples — DASLLAMA_GPU_SHEXP=1 opt-in. Dense (every token, every layer, one
     // fixed weight set) so residency carries no miss term; q8 only (the repack registers them fmt 0).
+    vulkan_bake_role(VkBakeRole.shexp)
     if (gpu_want_shexp() && t.config.n_ff_shexp > 0l && !t.config.moe_dense_shexp) {
         let nsh = t.config.n_ff_shexp
         let she = dim * nsh
@@ -2891,6 +2926,7 @@ def moe_gpu_upload_resident(t : Model) {
     // deltanet triples third — DASLLAMA_GPU_DN=1 opt-in: each recurrent layer's qkv/z-gate/
     // out-proj planes + the layer mark that routes its whole prefill attention through the
     // device chain. Layer-ascending; a budget stop leaves later layers CPU, a partial triple rolls back.
+    vulkan_bake_role(VkBakeRole.dn)
     if (dn_want) {
         var dn_marked = 0l
         var dn_stop = false
@@ -2934,6 +2970,7 @@ def moe_gpu_upload_resident(t : Model) {
     // attention quads fourth — DASLLAMA_GPU_ATTN=1 opt-in: each servable full-attention layer's
     // q|gate/k/v/wo planes + the layer mark that routes its whole prefill attention through the
     // device chain. Layer-ascending; a budget stop rolls back the partial quad.
+    vulkan_bake_role(VkBakeRole.attn)
     if (at_want) {
         let c = t.config
         // NEOX rope only (partial rotary implies NEOX per the loader); the chain has no bias /
@@ -2998,6 +3035,7 @@ def moe_gpu_upload_resident(t : Model) {
     // attention q/k/v triples — DASLLAMA_GPU_QKV=1 opt-in. LAST of the dense rails ON PURPOSE: it
     // is the lowest-value one and an earlier section exhausting stacks/VRAM starves those behind it
     // (a 224-stack cap once cut 6 DN layers = -14% tg). Pays only where GPU reads beat CPU reads.
+    vulkan_bake_role(VkBakeRole.qkv)
     if (gpu_want_qkv()) {
         var qkv_marked = 0l
         for (l in range64(layers)) {
@@ -3035,6 +3073,7 @@ def moe_gpu_upload_resident(t : Model) {
             to_log(LOG_INFO, "dasLLAMA: GPU MoE tier: q/k/v of {qkv_marked} attention layers resident\n")
         }
     }
+    vulkan_bake_role(VkBakeRole.expert)
     for (i in range64(want)) {
         let l = layers - 1l - i
         let f1 = fmt_at(t.we1_fmt, l)
@@ -3073,6 +3112,7 @@ def moe_gpu_upload_resident(t : Model) {
     // streamed tail: DASLLAMA_GPU_MOE_STREAM=N marks the next N layers below the resident set for
     // prefill streaming — device-layout planes gathered into pinned host mirrors the tier DMAs per
     // prefill. CPU planes stay (decode runs them); the walk is contiguous descending.
+    vulkan_bake_role(VkBakeRole.expert_stream)
     var sfrom = from_l
     for (i in range64(has_experts ? max(nstream, 0l) : 0l)) {
         let l = from_l - 1l - i
diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index 17506c827c..cb52dc10f2 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -796,7 +796,7 @@ def load_model_cached(path : string; mode : QuantMode = QuantMode.fp32) : Model
         var t = Model()
         let metal_first = get_metal_mode() != MetalMode.off && has_decode_override("metal")
         let vk_cfg = metal_first ? "" : moe_gpu_bake_tag()
-        let vk_tag = vk_cfg == "" ? "" : "vulkan|{vk_cfg}"
+        let vk_tag = vk_cfg   // dlim_vulkan_tag already carries the "vulkan|" prefix ("" = tier absent)
         var loaded = false
         if (vk_tag != "") {
             vulkan_bake_slice_begin()
@@ -836,7 +836,7 @@ def load_model_cached(path : string; mode : QuantMode = QuantMode.fp32) : Model
         // the vulkan flavor: the GPU walk slices the baked device-layout planes off the mapping
         // instead of re-gathering; ANY vulkan config switch changes the tag and rebakes below
         let vk_cfg = want_metal ? "" : moe_gpu_bake_tag()
-        let vk_tag = vk_cfg == "" ? "" : "vulkan|{vk_cfg}"
+        let vk_tag = vk_cfg   // dlim_vulkan_tag already carries the "vulkan|" prefix ("" = tier absent)
         if (vk_tag != "") {
             let img_v = image_path_for(path, vk_tag)
             vulkan_bake_slice_begin()
diff --git a/modules/dasLLAMA/dasllama/dasllama_math.das b/modules/dasLLAMA/dasllama/dasllama_math.das
index 187a7cc3cd..3a09dab5ce 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math.das
@@ -6,6 +6,7 @@ module dasllama_math shared public
 require math
 require daslib/fio  // has_env_variable: DAS_JOBQUE_TEAM_RANK_GATE suppresses the profile's team_rank_gate knob
 require dasllama/dasllama_env  // env_flag/env_int64: the shared typed readers + the knob registry
+require dasllama/dasllama_config  // DlimVulkanConfig — the dry-bake seam's config argument
 require daslib/jobque_boost public  // matmul's threaded path expands parallel_for; consumers need its symbols
 require daslib/jobque_profile  // named trace categories + unit markers (set_trace_tags registers them)
 require dasllama/dasllama_par  // maybe_parallel_for: thread-or-inline a kernel body on a runtime size flag
@@ -2169,6 +2170,21 @@ def public set_moe_gpu_expert_q8n_probe(f : function<() : bool>) {
     g_moe_gpu_expert_q8n = f
 }
 
+[unused_argument(v)]
+def private moe_gpu_no_dry_bake(v : DlimVulkanConfig) : bool => false
+
+var private g_moe_gpu_dry_bake = @@moe_gpu_no_dry_bake
+
+//! A GPU tier registers its OFFLINE-bake arm here: the load walk runs its full accept/refuse
+//! arithmetic against the config's numbers, gathers collect, and no device call is made.
+def public set_moe_gpu_dry_bake_arm(f : function<(v : DlimVulkanConfig) : bool>) {
+    g_moe_gpu_dry_bake = f
+}
+
+//! Arm the offline bake (false = no GPU backend in this build, or the config disagrees with
+//! this process' env wants — the tier logs the exact mismatch).
+def public moe_gpu_dry_bake_arm(v : DlimVulkanConfig) : bool => invoke(g_moe_gpu_dry_bake, v)
+
 def private moe_gpu_no_bake_tag : string => ""
 
 var private g_moe_gpu_bake_tag = @@moe_gpu_no_bake_tag
diff --git a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
index 87d944168d..cc9cd3760a 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
@@ -3994,6 +3994,8 @@ struct private GpuState {
     has_coopmat2 : bool      // device supports NV_cooperative_matrix2 (tensor-addressed wg tiles + decode fns)
     coopmat_mode : int       // Q8_0 prefill GEMM: 0 = sdot4, 1 = f16 coopmat, 2 = int8 coopmat, 3 = mul_mm L-tile (default), 4 = cm2 decode-in-load
     weight_budget : int64    // resident-weight cap — queried heap budget minus reserve, or VRAM_BUDGET
+    dry : bool               // OFFLINE BAKE: accept/refuse arithmetic runs, every device call is gated off
+    msr : int64              // maxStorageBufferRange — device-queried at init, config-supplied when dry
     @do_not_delete stacks : array<VkStack>
     // the resident driver's weight arenas, one per format present (see the arena section). Separate
     // from `stacks` on purpose: the two tiers never co-arm on one model, and the arena has no
@@ -4390,6 +4392,60 @@ def private resolve_weight_cap(heap : VkHeapInfo) : int64 {
     return cap
 }
 
+// stream-slot carve: exact loader-reported need, else the legacy constant (direct-upload paths).
+// One helper — the dry init must carve exactly as the live one does.
+def private carve_stream_reserve {
+    if (gpu_want_moe_stream() != 0l) {
+        let need = moe_gpu_stream_need()
+        if (need > 0l) {
+            g_gpu.stream_reserve = 2l * need
+        } elif (gpu_want_moe_stream() > 0l) {
+            g_gpu.stream_reserve = STREAM_RESERVE
+        }
+        g_gpu.weight_budget = max(g_gpu.weight_budget - g_gpu.stream_reserve, 0l)
+    }
+}
+
+var private g_vk_dry_want = false
+var private g_vk_dry_cfg = DlimVulkanConfig()
+
+// fill the env-else-programmatic wants half of a config section (the caps half is the
+// device's / the dry config's) — shared by the live source and the dry arm's verify
+def private vk_dlim_wants_fill(var v : DlimVulkanConfig) {
+    v.moe_layers = gpu_want_moe_layers()
+    v.moe_stream = gpu_want_moe_stream()
+    v.dn = gpu_want_dn()
+    v.attn = gpu_want_attn()
+    v.dnd = gpu_want_dnd()
+    v.shexp = gpu_want_shexp()
+    v.qkv = gpu_want_qkv()
+    v.cls = gpu_want_cls_upload()   // the WALK's gate, not the arm-intent (they had split defaults)
+    v.dense = gpu_want_dense()
+    v.dense_attn = gpu_want_dense_attn()
+    v.dense_shexp = gpu_want_dense_shexp()
+}
+
+//! Arm the tier for an OFFLINE bake: the load walk runs its full accept/refuse arithmetic
+//! against the config's numbers, gathers collect into the bake blob, and no Vulkan call is
+//! made — no instance, no device, no VRAM. The converter's `-f vulkan` rail.
+def vulkan_dry_bake_arm(v : DlimVulkanConfig) : bool {
+    // the walk's gates read env-else-programmatic wants — a bake whose config disagrees with
+    // them would write an image whose identity lies about its own plan. Fail closed, name both.
+    var w = v
+    vk_dlim_wants_fill(w)
+    if (dlim_vulkan_tag(w) != dlim_vulkan_tag(v)) {
+        to_log(LOG_ERROR, "dasLLAMA vulkan tier: dry-bake config disagrees with this process' wants (set the DASLLAMA_GPU_* knobs to match)\n  config {dlim_vulkan_tag(v)}\n  wants  {dlim_vulkan_tag(w)}\n")
+        return false
+    }
+    g_vk_dry_want = true
+    g_vk_dry_cfg = v
+    set_moe_gpu_layer_count(v.moe_layers)
+    if (!moe_gpu_tier_installed()) {
+        install_moe_gpu_tier(@@vk_moe_ffn, @@vk_moe_upload_stack, @@vk_moe_cls, @@vk_moe_dense, @@vk_moe_drop_stacks, @@vk_moe_dn, @@vk_moe_attn)
+    }
+    return true
+}
+
 def private vk_moe_init : bool {
     if (g_init_failed) {   // checked FIRST: a partially-built g_gpu must never report ready
         return false
@@ -4397,6 +4453,24 @@ def private vk_moe_init : bool {
     if (g_gpu != null) {
         return true
     }
+    if (g_vk_dry_want) {
+        // DlimVulkanConfig numbers feed the SAME arithmetic — a dry bake cannot drift from live
+        if (g_vk_dry_cfg.subgroup_size < 32) {
+            to_log(LOG_ERROR, "dasLLAMA vulkan tier: config subgroupSize {g_vk_dry_cfg.subgroup_size} < 32 — bake declined\n")
+            g_init_failed = true
+            return false
+        }
+        g_gpu = new GpuState()
+        g_gpu.dry = true
+        g_gpu.coopmat_mode = g_vk_dry_cfg.coopmat_mode
+        g_gpu.has_coopmat = g_vk_dry_cfg.coopmat_mode > 0
+        g_gpu.has_coopmat2 = g_vk_dry_cfg.coopmat_mode == 4
+        g_gpu.rows_per_wg = int64((WG_X + uint(g_vk_dry_cfg.subgroup_size) - 1u) / uint(g_vk_dry_cfg.subgroup_size))
+        g_gpu.msr = g_vk_dry_cfg.max_storage_range
+        g_gpu.weight_budget = g_vk_dry_cfg.vram_mb * 1_000_000l
+        carve_stream_reserve()
+        return true
+    }
     g_init_failed = true   // cleared only on full success
     if (volkInitialize() != 0) {
         to_log(LOG_ERROR, "dasLLAMA vulkan tier: no Vulkan loader\n")
@@ -4472,6 +4546,9 @@ def private vk_moe_init : bool {
         return false
     }
     g_gpu.rows_per_wg = int64((WG_X + sg - 1u) / sg)   // = gl_NumSubgroups for our 1D workgroup
+    var pdp : VkPhysicalDeviceProperties
+    vkGetPhysicalDeviceProperties(g_gpu.phys, pdp)
+    g_gpu.msr = int64(pdp.limits.maxStorageBufferRange)
     // env-vs-auto resolution shared with the DlimConfiguration source (resolve_weight_cap)
     let heap = query_heap_info(g_gpu.phys)
     g_gpu.weight_budget = resolve_weight_cap(heap)
@@ -4484,16 +4561,7 @@ def private vk_moe_init : bool {
         }
         to_log(LOG_INFO, "dasLLAMA vulkan tier: device heap budget {heap.budget / 1000000l} MB (used {heap.used / 1000000l}), weight cap {g_gpu.weight_budget / 1000000l} MB\n")
     }
-    // stream-slot carve: exact loader-reported need, else the legacy constant (direct-upload paths)
-    if (gpu_want_moe_stream() != 0l) {
-        let need = moe_gpu_stream_need()
-        if (need > 0l) {
-            g_gpu.stream_reserve = 2l * need
-        } elif (gpu_want_moe_stream() > 0l) {
-            g_gpu.stream_reserve = STREAM_RESERVE
-        }
-        g_gpu.weight_budget = max(g_gpu.weight_budget - g_gpu.stream_reserve, 0l)
-    }
+    carve_stream_reserve()
     // ReBAR: DL|HV|HC on the full-VRAM heap (the >1GB check excludes the 256MiB legacy window)
     if (env_flag("DASLLAMA_VK_REBAR", true)) {
         var rmp : VkPhysicalDeviceMemoryProperties
@@ -4678,7 +4746,8 @@ def private stack_plane_bytes(n, rows : int64; fmt : int) : tuple<wq : int64; ws
 def private make_stack_shell(base, elems : int64; fmt : int; wqcap, wscap : int64; xfer_shared : bool = false) : int {
     // q8n has no scale plane (wscap 0) — floor the buffer so its descriptor slot stays valid
     var st = VkStack(base = base, elems = elems, fmt = fmt, wqbytes = wqcap,
-                     wqbuf = make_device_buf(wqcap, xfer_shared), wsbuf = make_device_buf(max(wscap, 64l), xfer_shared), wsbytes = wscap)
+                     wqbuf = g_gpu.dry ? 0ul : make_device_buf(wqcap, xfer_shared),
+                     wsbuf = g_gpu.dry ? 0ul : make_device_buf(max(wscap, 64l), xfer_shared), wsbytes = wscap)
     g_gpu.stacks |> push(st)
     return length(g_gpu.stacks) - 1
 }
@@ -4716,13 +4785,15 @@ def private ensure_gemv_scratch(si : int) {
 // memory the copy engine DMA-streams into a slot per prefill). No VRAM spent here.
 def private vk_moe_stream_stack(wq : uint8 const?; ws : uint8 const?; woff : int64; n, rows : int64; fmt : int) : bool {
     let pb = stack_plane_bytes(n, rows, fmt)
-    var ss = StreamStack(base = woff, elems = rows * n, fmt = fmt, wqbytes = pb.wq, wsbytes = pb.ws,
-                         hwq = make_host_buf(pb.wq, false, [xfer_shared = true]),
-                         hws = make_host_buf(max(pb.ws, 64l), false, [xfer_shared = true]))
-    unsafe {
-        par_memcpy(ss.hwq.mapped, reinterpret<void?>(wq), pb.wq)
-        if (pb.ws > 0l) {   // q8n mirrors carry no scale plane
-            par_memcpy(ss.hws.mapped, reinterpret<void?>(ws), pb.ws)
+    var ss = StreamStack(base = woff, elems = rows * n, fmt = fmt, wqbytes = pb.wq, wsbytes = pb.ws)
+    if (!g_gpu.dry) {
+        ss.hwq = make_host_buf(pb.wq, false, [xfer_shared = true])
+        ss.hws = make_host_buf(max(pb.ws, 64l), false, [xfer_shared = true])
+        unsafe {
+            par_memcpy(ss.hwq.mapped, reinterpret<void?>(wq), pb.wq)
+            if (pb.ws > 0l) {   // q8n mirrors carry no scale plane
+                par_memcpy(ss.hws.mapped, reinterpret<void?>(ws), pb.ws)
+            }
         }
     }
     if (length(g_gpu.stream_stacks) % 3 == 2) {   // walk order gate/up/down: this one is a down
@@ -4757,8 +4828,10 @@ def vk_moe_upload_stack(wq : uint8 const?; ws : uint8 const?; woff : int64; n :
         return false
     }
     let si = make_stack_shell(woff, rows * n, fmt, wqbytes, wsbytes)
-    upload_region(g_gpu.stacks[si].wqbuf, wq, wqbytes)
-    upload_region(g_gpu.stacks[si].wsbuf, ws, wsbytes)
+    if (!g_gpu.dry) {
+        upload_region(g_gpu.stacks[si].wqbuf, wq, wqbytes)
+        upload_region(g_gpu.stacks[si].wsbuf, ws, wsbytes)
+    }
     g_gpu.resident_bytes += wqbytes + wsbytes
     return true
 }
@@ -4769,8 +4842,10 @@ def vk_moe_drop_stacks(n : int; stream : bool) {
     if (stream) {
         for (_i in range(n)) {
             let k = length(g_gpu.stream_stacks) - 1
-            destroy_host_buf(g_gpu.stream_stacks[k].hwq)
-            destroy_host_buf(g_gpu.stream_stacks[k].hws)
+            if (!g_gpu.dry) {
+                destroy_host_buf(g_gpu.stream_stacks[k].hwq)
+                destroy_host_buf(g_gpu.stream_stacks[k].hws)
+            }
             g_gpu.stream_stacks |> resize(k)
         }
         return
@@ -4780,8 +4855,10 @@ def vk_moe_drop_stacks(n : int; stream : bool) {
         assert(!g_gpu.stacks[k].gemv_made && !g_gpu.stacks[k].batch_made && !g_gpu.stacks[k].cls_made,
             "dasLLAMA vulkan tier: dropping a stack with live dispatch state")
         g_gpu.resident_bytes -= g_gpu.stacks[k].wqbytes + g_gpu.stacks[k].wsbytes
-        destroy_device_buf(g_gpu.stacks[k].wqbuf)
-        destroy_device_buf(g_gpu.stacks[k].wsbuf)
+        if (!g_gpu.dry) {
+            destroy_device_buf(g_gpu.stacks[k].wqbuf)
+            destroy_device_buf(g_gpu.stacks[k].wsbuf)
+        }
         g_gpu.stacks |> resize(k)
     }
 }
@@ -4793,6 +4870,14 @@ def vk_drop_model_state {
     if (g_gpu == null) {
         return
     }
+    if (g_gpu.dry) {
+        // dry bake owns no device objects — reset the accounting shells only
+        g_gpu.stacks |> clear()
+        g_gpu.stream_stacks |> clear()
+        g_gpu.arenas |> clear()
+        g_gpu.resident_bytes = 0l
+        return
+    }
     vk_check(vkQueueWaitIdle(g_gpu.queue), null)
     if (g_gpu.xfer_fam >= 0 && g_gpu.xfer_value > 0ul) {
         xfer_host_wait(g_gpu.xfer_value)   // in-flight transfer-queue copies retire before the sweeps
@@ -4974,15 +5059,13 @@ def private arena_reserve(fmt : int; cap_blocks : int64) : bool {
     // q8n has no scale plane — floor the ws buffer so its descriptor slots stay valid (stack-shell rule)
     let sbytes = max(cap_blocks * bb.ws, 64l)
     // maxStorageBufferRange is the real ceiling (uint32 indexing reaches 16GiB); NV/AMD report 4GiB
-    var lp : VkPhysicalDeviceProperties
-    vkGetPhysicalDeviceProperties(g_gpu.phys, lp)
-    let shard_cap = int64(lp.limits.maxStorageBufferRange)
+    let shard_cap = g_gpu.msr
     if (qbytes > shard_cap || sbytes > shard_cap) {
         to_log(LOG_WARNING, "dasLLAMA vulkan arena: fmt {fmt} needs {qbytes} quant + {sbytes} scale bytes — over the device's {shard_cap}B storage-range cap\n")
         return false
     }
     var a = ArenaFmt(fmt = fmt, cap_blocks = cap_blocks, wqbytes = qbytes, wsbytes = sbytes,
-                     wqbuf = make_device_buf(qbytes), wsbuf = make_device_buf(sbytes))
+                     wqbuf = g_gpu.dry ? 0ul : make_device_buf(qbytes), wsbuf = g_gpu.dry ? 0ul : make_device_buf(sbytes))
     g_gpu.arenas |> insert(fmt, a)
     return true
 }
@@ -5002,9 +5085,11 @@ def private arena_place(wq : uint8 const?; ws : uint8 const?; n, rows : int64; f
         let blk = a.blocks
         a.blocks += need
         let bb = arena_block_bytes(fmt)
-        upload_region_at(a.wqbuf, blk * bb.wq, wq, need * bb.wq)
-        if (bb.ws > 0l) {
-            upload_region_at(a.wsbuf, blk * bb.ws, ws, need * bb.ws)
+        if (!g_gpu.dry) {
+            upload_region_at(a.wqbuf, blk * bb.wq, wq, need * bb.wq)
+            if (bb.ws > 0l) {
+                upload_region_at(a.wsbuf, blk * bb.ws, ws, need * bb.ws)
+            }
         }
         return blk
     }
@@ -5474,6 +5559,9 @@ def vk_rdec_prepare(n_layers, dim, qd, kv_dim, head_size, n_heads, hidden, vocab
         to_log(LOG_WARNING, "dasLLAMA vulkan resident: dim {dim} > {AR_MAX_DIM} or head_size {head_size} > 256 exceeds the workgroup row slabs\n")
         return false
     }
+    if (g_gpu.dry) {
+        return true   // guards above ARE the plan decision; everything below is device state
+    }
     g_rd = new RDec(ready = false, n_layers = n_layers, dim = dim, qd = qd, kv_dim = kv_dim,
                  head_size = head_size, n_heads = n_heads, kv_mul = n_heads / (kv_dim / head_size),
                  hidden = hidden, vocab = vocab, seq_cap = seq_cap, neox = neox, eps = eps, scale = scale,
@@ -5525,6 +5613,9 @@ def vk_rdec_prepare(n_layers, dim, qd, kv_dim, head_size, n_heads, hidden, vocab
 //! rms_final], dim floats each, exactly the layout the layer w_offs index. Under qk_norm the
 //! per-head [rms_q[l], rms_k[l]] x L rows (head_size floats each) follow.
 def vk_rdec_upload_norms(norms : array<float>) {
+    if (g_gpu != null && g_gpu.dry) {
+        return
+    }
     assert(g_rd != null, "vk_rdec_upload_norms before prepare")
     upload_region_at(g_rd.norms_dev, 0l, unsafe(addr<uint8 const?>(norms[0])), long_length(norms) * 4l)
     // the fused-rail constants: eps/ascale past the norm rows, and (under qk_norm) a copy of the
@@ -5551,6 +5642,9 @@ def vk_rdec_upload_norms(norms : array<float>) {
 //! once per layer after prepare. `w_ffn_off`/`w_next_off` are the rms_ffn[l] and rms_att[l+1]
 //! (or rms_final for the last layer) offsets in the norms buffer (dim-element units).
 def vk_rdec_set_layer(l : int64; bq, bk, bv, bo, b1, b3, b2 : int64; fq, fk, fv, fo, f1, f3, f2 : int) {
+    if (g_gpu != null && g_gpu.dry) {
+        return
+    }
     assert(g_rd != null, "vk_rdec_set_layer before prepare")
     while (long_length(g_rd.layers) <= l) {
         g_rd.layers |> emplace(RLayer())
@@ -5669,6 +5763,9 @@ def vk_rdec_set_layer(l : int64; bq, bk, bv, bo, b1, b3, b2 : int64; fq, fk, fv,
 //! Register the classifier plane (arena block + format) and build the prologue / final-norm / cls
 //! sets. Call after all layers are set.
 def vk_rdec_set_cls(cls_block : int64; cls_fmt : int) {
+    if (g_gpu != null && g_gpu.dry) {
+        return
+    }
     assert(g_rd != null, "vk_rdec_set_cls before prepare")
     let dim = g_rd.dim
     let vocab = g_rd.vocab
@@ -8950,20 +9047,15 @@ def private vk_caps_fill(phys : VkPhysicalDevice; var v : DlimVulkanConfig) {
 // The DlimConfiguration vulkan source — RESOLVED values (the old tag folded raw env strings,
 // so "auto" hid device-derived byte differences and a moving heap budget).
 def private vk_dlim_source(var v : DlimVulkanConfig) : bool {
+    if (g_vk_dry_want) {
+        // an offline bake IS its config — echo it, never probe (there may be no device at all)
+        v = g_vk_dry_cfg
+        return true
+    }
     if (!vulkan_moe_gpu_arm()) {
         return false
     }
-    v.moe_layers = gpu_want_moe_layers()
-    v.moe_stream = gpu_want_moe_stream()
-    v.dn = gpu_want_dn()
-    v.attn = gpu_want_attn()
-    v.dnd = gpu_want_dnd()
-    v.shexp = gpu_want_shexp()
-    v.qkv = gpu_want_qkv()
-    v.cls = gpu_want_cls_upload()   // the WALK's gate, not the arm-intent (they had split defaults)
-    v.dense = gpu_want_dense()
-    v.dense_attn = gpu_want_dense_attn()
-    v.dense_shexp = gpu_want_dense_shexp()
+    vk_dlim_wants_fill(v)
     if (g_gpu != null) {
         vk_caps_fill(g_gpu.phys, v)
     } else {
@@ -8990,6 +9082,7 @@ def dasllama_math_vulkan_register() {
     set_moe_gpu_arm("vulkan", @@vulkan_moe_gpu_arm)
     set_moe_gpu_bake_tag(@@vk_bake_tag)
     set_dlim_vulkan_source(@@vk_dlim_source)
+    set_moe_gpu_dry_bake_arm(@@vulkan_dry_bake_arm)
     set_moe_gpu_vram_report(@@vk_resident_bytes)
     set_moe_gpu_device_report(@@vk_device_name)
     set_moe_gpu_budget_hooks(@@vk_weight_budget, @@vk_plane_bytes)
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 56710c43f5..322a570f86 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -13,7 +13,8 @@ options stack = 65536   // dasLLAMA program-root convention (options stack does
 // The config is EXPLICIT (DlimConfiguration): `--dump-config` prints/writes this box's config as
 // JSON; `--config x.json` bakes against a supplied one — applied knob-by-knob, then verified
 // fail-closed against the resulting identity, so a knob that did not take is an error, never a
-// silently different image.
+// silently different image. `-f vulkan` bakes OFFLINE: the GPU walk's accept/refuse arithmetic
+// runs against the config's numbers (dry tier), gathers collect into vkblob — no VRAM touched.
 //
 // Conversion is I/O bound at both ends: the transcode is ~5% of wall time, the rest is reading the
 // GGUF and writing the image. Both numbers are reported per stage so a slow box is diagnosable
@@ -130,7 +131,7 @@ def private flavor_tag(f : Flavor) : string {
         if (cfg == "") {
             panic("dasllama-convert: --flavor vulkan needs the vulkan tier armed (see DASLLAMA_GPU_* in modules/dasLLAMA/ENVIRONMENT.md)")
         }
-        return "vulkan|{cfg}"
+        return cfg   // dlim_vulkan_tag already carries the "vulkan|" prefix
     }
     return ""
 }
@@ -190,6 +191,8 @@ def main() : int {
     // the backend pin must precede the identity: image_identity names the active kernel backend
     apply_box_profile_runtime()
     var qm = cfg.quant
+    var want = DlimConfiguration()
+    var have_want = false
     if (cfg.config != "") {
         var text = ""
         fopen(cfg.config, "rb") $(f) {
@@ -201,7 +204,6 @@ def main() : int {
             to_log(LOG_ERROR, "dasllama-convert: cannot read --config '{cfg.config}'\n")
             return 2
         }
-        var want = DlimConfiguration()
         if (!dlim_config_from_json(text, want)) {
             to_log(LOG_ERROR, "dasllama-convert: --config '{cfg.config}' is not a DlimConfiguration JSON\n")
             return 2
@@ -224,6 +226,26 @@ def main() : int {
             to_log(LOG_ERROR, "dasllama-convert: --config could not be fully applied on this host (cross-box backend targeting lands later in the arc):\n  want {want_ident}\n  have {have_ident}\n")
             return 2
         }
+        have_want = true
+    }
+    if (cfg.flavor == Flavor.vulkan) {
+        // OFFLINE bake: the walk's accept/refuse arithmetic runs against the config's numbers,
+        // the gathers collect, and no Vulkan call is made — no instance, no device, no VRAM
+        var vkc = DlimVulkanConfig()
+        if (have_want && want.vulkan_on) {
+            vkc = want.vulkan
+        } else {
+            let probed = dlim_config_current("{qm}")
+            if (!probed.vulkan_on) {
+                to_log(LOG_ERROR, "dasllama-convert: --flavor vulkan needs the vulkan tier armed (DASLLAMA_GPU=1, see modules/dasLLAMA/ENVIRONMENT.md) or a --config carrying a vulkan section\n")
+                return 2
+            }
+            vkc = probed.vulkan
+        }
+        if (!moe_gpu_dry_bake_arm(vkc)) {
+            to_log(LOG_ERROR, "dasllama-convert: offline vulkan bake could not arm — see the log above\n")
+            return 2
+        }
     }
     let tag = flavor_tag(cfg.flavor)
     let out = cfg.out != "" ? cfg.out : image_path_for(cfg.model, tag)
@@ -243,6 +265,9 @@ def main() : int {
     let ts = ref_time_ticks()
     // the job que carries the transcode/repack passes; the load spins its own if we do not
     with_job_que() {
+        if (cfg.flavor == Flavor.vulkan) {
+            vulkan_bake_begin()   // the load's GPU walk collects into the bake blob (dry — no uploads)
+        }
         var m <- load_model_(cfg.model, qm)
         let ts_load = ref_time_ticks()
         if (cfg.flavor == Flavor.metal) {
@@ -251,6 +276,10 @@ def main() : int {
                 rc = 1
             }
         }
+        if (rc == 0 && cfg.flavor == Flavor.vulkan && !vulkan_bake_take(m)) {
+            to_log(LOG_ERROR, "dasllama-convert: the GPU walk collected nothing — the tier declined this model under the supplied config\n")
+            rc = 1
+        }
         if (rc == 0 && !save_model_image(m, out, tag)) {
             to_log(LOG_ERROR, "dasllama-convert: writing '{out}' failed — see the error above\n")
             rc = 1

From c2206b78a4a84f9a763ae6d90520fab1ad64b81c Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 22:24:43 -0700
Subject: [PATCH 06/30] dlim quant plumbing: the identity's quant field is
 real, not a hardcoded "q8"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

image_identity / image_path_for / save_image / load_image (+ the model wrappers) take a quant
string, defaulted "q8" — so every existing rail (load_model_cached's q8-gated branch, the
tower/whisper rails whose tags already encode their mode) behaves exactly as before, while the
converter stamps the REAL -q/-config quant into the identity, filename, and embedded config.
Before this, a `-q q4_0` conversion wrote a file whose name and identity claimed q8 — colliding
with the actual q8 image's path. Non-q8 images remain converter-only artifacts (the load path
still images q8 only); they just stop lying about themselves.

Gates: image mechanics+smol arms 9/9 (existing q8/tag defaults byte-stable), converter
compiles+help, lint+format clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_image.das | 24 ++++++++++----------
 utils/dasllama-convert/main.das              |  7 +++---
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index cb52dc10f2..23fb762a39 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -53,15 +53,15 @@ struct ImgSection {
 // the box + knob identity an image is valid for; folded into filename AND header. A PURE
 // formatter of DlimConfiguration — the backend-select side effect lives in the config's cpu
 // source, so callers need no ordering ritual. `tag` distinguishes kinds sharing one source path.
-def image_identity(tag : string = "") : string {
-    return dlim_identity(dlim_config_current(), IMAGE_VERSION, tag)
+def image_identity(tag : string = ""; quant : string = "q8") : string {
+    return dlim_identity(dlim_config_current(quant), IMAGE_VERSION, tag)
 }
 
 // the image path for (gguf, current identity) — knob combos coexist as separate files
 // (the full 64-bit hash keeps that deterministic in practice; the header check would catch
 // a collision loudly, but two identities fighting over one path re-save forever)
-def image_path_for(gguf_path : string; tag : string = "") : string {
-    return "{gguf_path}.{hash(image_identity(tag))}.dlim"
+def image_path_for(gguf_path : string; tag : string = ""; quant : string = "q8") : string {
+    return "{gguf_path}.{hash(image_identity(tag, quant))}.dlim"
 }
 
 def private pad_to_page(cur : uint64) : uint64 {
@@ -418,12 +418,12 @@ def private write_plane(var w : ImgWriter; var sections : array<ImgSection>;
 //! Serialize a loaded weight-carrying struct as a prepared image: array planes page-aligned raw
 //! (borrowed back at load), everything else archived. Tmp+rename: atomic on POSIX; on Windows a
 //! brief missing-file window lets a concurrent reader regenerate. Caller supplies `serialize_image_meta`/`image_post_load` (`_::` dispatch).
-def save_image(var t; path : string; tag : string = "") : bool {
+def save_image(var t; path : string; tag : string = ""; quant : string = "q8") : bool {
     // per-writer tmp name: concurrent savers (parallel test workers on one cache miss) must
     // not clobber each other's half-written file; last atomic rename wins with same content
     let tmp_path = "{path}.{ref_time_ticks()}.tmp"
     // one config snapshot serves the meta embed AND the header hash — they must agree
-    let dcfg = dlim_config_current()
+    let dcfg = dlim_config_current(quant)
     let ident = dlim_identity(dcfg, IMAGE_VERSION, tag)
     var fend = 0ul
     var meta_off = 0ul
@@ -563,8 +563,8 @@ def save_image(var t; path : string; tag : string = "") : bool {
 
 //! Model entry point (the AudioTower one is load_audio_tower's cache in dasllama_audio).
 //! `tag` names the flavor (METAL_IMAGE_TAG for blob-only metal-flavor models, "" planar).
-def save_model_image(var t : Model; path : string; tag : string = "") : bool {
-    return save_image(t, path, tag)
+def save_model_image(var t : Model; path : string; tag : string = ""; quant : string = "q8") : bool {
+    return save_image(t, path, tag, quant)
 }
 
 // ===== load =====
@@ -592,7 +592,7 @@ def private borrow_plane(bp : uint8 const?; msize : uint64; path : string;
 //! Map a prepared image and rebuild the struct with zero O(model) work: array plane fields borrow
 //! the mapping (finalizer forgets + unmaps), archive blob restores everything else. false = absent /
 //! wrong identity / wrong version — caller regenerates from gguf. Same `_::` contract as save_image.
-def load_image(path : string; var t; tag : string = "") : bool {
+def load_image(path : string; var t; tag : string = ""; quant : string = "q8") : bool {
     if (!stat(path).is_valid) {
         return false
     }
@@ -635,7 +635,7 @@ def load_image(path : string; var t; tag : string = "") : bool {
         unsafe(fmap_close(base, msize))
         return false
     }
-    let want_ident = image_identity(tag)
+    let want_ident = image_identity(tag, quant)
     if (read_u64(bp, 40l) != hash(want_ident)) {
         // same version ⇒ the meta head is readable: say WHAT the image was baked for, not
         // just that a 64-bit hash missed (bounds were validated above)
@@ -773,8 +773,8 @@ def private guard_interp_gguf_load(path : string) {
 }
 
 //! Model entry point — see load_image (`tag` = the flavor, like save_model_image).
-def load_model_image(path : string; var t : Model; tag : string = "") : bool {
-    if (!load_image(path, t, tag)) {
+def load_model_image(path : string; var t : Model; tag : string = ""; quant : string = "q8") : bool {
+    if (!load_image(path, t, tag, quant)) {
         return false
     }
     // AFTER the plane borrows (image_post_load runs before them, when every array is still
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 322a570f86..09b0326489 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -248,10 +248,11 @@ def main() : int {
         }
     }
     let tag = flavor_tag(cfg.flavor)
-    let out = cfg.out != "" ? cfg.out : image_path_for(cfg.model, tag)
+    let qs = "{qm}"
+    let out = cfg.out != "" ? cfg.out : image_path_for(cfg.model, tag, qs)
     to_log(LOG_INFO, "dasllama-convert: {cfg.model}\n")
     to_log(LOG_INFO, "dasllama-convert:   -> {out}\n")
-    to_log(LOG_INFO, "dasllama-convert:   identity {image_identity(tag)}\n")
+    to_log(LOG_INFO, "dasllama-convert:   identity {image_identity(tag, qs)}\n")
 
     if (!cfg.keep_stale_tmp) {
         sweep_stale_tmp(cfg.model)
@@ -280,7 +281,7 @@ def main() : int {
             to_log(LOG_ERROR, "dasllama-convert: the GPU walk collected nothing — the tier declined this model under the supplied config\n")
             rc = 1
         }
-        if (rc == 0 && !save_model_image(m, out, tag)) {
+        if (rc == 0 && !save_model_image(m, out, tag, qs)) {
             to_log(LOG_ERROR, "dasllama-convert: writing '{out}' failed — see the error above\n")
             rc = 1
         }

From fab2bc8e68a5670cd20663f9e4dcaa97fb3e6451 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 22:44:51 -0700
Subject: [PATCH 07/30] =?UTF-8?q?dlim=20arc=20phase=20C=20core:=20P3=20tri?=
 =?UTF-8?q?m=20=E2=80=94=20the=20vulkan=20flavor=20drops=20the=20CPU=20wei?=
 =?UTF-8?q?ght=20families=20(-44%)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`dasllama-convert -f vulkan --trim` bakes a vulkan image WITHOUT the big CPU weight planes:
after the (dry) bake, trim_model_planes packs the emb/cls region into new Model planes
embq/embs (q8: mblob-style 34B interleaved blocks; kq: the region's plane pair copied verbatim,
repack layout preserved, rebased to superblock 0), sets planes_trimmed (meta 66+3), and FREES
qblob/qscales*/wblob/bf16blob/k*q/k*s/q40*/q51*/mx*/q4* — generate-then-free, so save_image
writes them as empty planes with zero writer changes. fblob (norms/rope) stays. STRICT v1 gate:
every baked-plan role must be arena (pure resident-driver dense, no MTP) or the trim declines.

embed_row serves all three access modes from the trimmed planes (q8 via dequant_embq_row; kq
grp<mr> and disk-order arms over embq/embs rebased); the decode path is otherwise all-GPU on
the resident driver. Fail-closed: the three gather wrappers PANIC on any live gather against a
trimmed model (covers slot re-bind, stale-plan divergence, and every CPU re-gather path), and
mm_cls panics if the classifier is not GPU-served.

The trim is part of the flavor identity: DlimVulkanConfig.trim -> " T" in the tag, driven by
the new DASLLAMA_TRIM knob at serve (registered; ENVIRONMENT.md regenerated) and by --trim in
the converter (the dry-arm wants-check treats trim as save-shaping, not walk-shaping).

Gate so far: Qwen3-4B Q4_K_M trimmed image 2738 MB vs 4856 untrimmed (-44%); maps + slices +
arms the resident driver under DASLLAMA_TRIM=1 with zero divergence warnings; env-registry
14/14; image mechanics+smol arms 9/9; lint+format clean. OPEN: decode IDS parity trimmed vs
untrimmed (the embq read path needs a real generation to prove — next slice).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/ENVIRONMENT.md               |   1 +
 modules/dasLLAMA/dasllama/dasllama_common.das | 173 ++++++++++++++++--
 modules/dasLLAMA/dasllama/dasllama_config.das |   3 +-
 modules/dasLLAMA/dasllama/dasllama_env.das    |   2 +
 modules/dasLLAMA/dasllama/dasllama_image.das  |   5 +-
 .../dasllama/dasllama_math_vulkan.das         |   2 +
 utils/dasllama-convert/main.das               |  12 ++
 7 files changed, 184 insertions(+), 14 deletions(-)

diff --git a/modules/dasLLAMA/ENVIRONMENT.md b/modules/dasLLAMA/ENVIRONMENT.md
index 92be63f40a..80504fcf27 100644
--- a/modules/dasLLAMA/ENVIRONMENT.md
+++ b/modules/dasLLAMA/ENVIRONMENT.md
@@ -95,6 +95,7 @@ Vulkan GPU backend. Present only where the dasVulkan package is installed.
 | `DASLLAMA_MM_SMALLD` | number | 64 | Small-d cutoff routing narrow roles (k/v) to the small tier; widening measured worse, so this is an instrument. |
 | `DASLLAMA_VK_FUSE` | flag | on | Fused decode tail (add+rms+requant, qk-norm+rope); 0 pins the split dispatches for a same-build A/B. |
 | `DASLLAMA_VK_XFERQ` | flag | on | Stream expert uploads on the dedicated transfer queue, overlapped via a timeline semaphore; 0 keeps the single-queue rail. |
+| `DASLLAMA_TRIM` | flag | off | Serve from P3-trimmed vulkan images (big CPU weight families dropped; folded into the flavor identity). |
 | `DASLLAMA_VK_MEMPRIO` | flag | on | Tag allocations high-priority (VK_EXT_memory_priority) so the driver demotes desktop memory, not ours. |
 | `DASLLAMA_VK_FA` | flag | on | Vulkan flash-attention kernel; 0 falls back to the chunked path. |
 | `DASLLAMA_VK_REBAR` | flag | on | Use a ReBAR device-local host-visible heap when one larger than 1GB is present. |
diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index a242889881..ade76d34bf 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -549,6 +549,9 @@ def private moe_gpu_gather_stack(t : Model; woff : int64; n, rows, slice_rows :
     if (vk_bake_slice(t, 0, woff, n, rows, wq, ws)) {
         return
     }
+    if (t.planes_trimmed) {
+        panic("dasLLAMA: planes_trimmed image — live gather impossible (baked plan diverged, or a re-gather was requested); rebake without --trim or match the image's config")
+    }
     invoke(g_layout_gather, t, woff, n, rows, slice_rows, mr, kgroup, wbias, wq, ws)
 }
 
@@ -558,6 +561,9 @@ def private moe_gpu_gather_stack_kq(t : Model; fmt : KqFmt; woff : int64; n, row
     if (vk_bake_slice(t, int(fmt), woff, n, rows, wq, ws)) {
         return
     }
+    if (t.planes_trimmed) {
+        panic("dasLLAMA: planes_trimmed image — live gather impossible (baked plan diverged, or a re-gather was requested); rebake without --trim or match the image's config")
+    }
     invoke(g_layout_gather_kq, t, fmt, woff, n, rows, slice_rows, repacked, mr, wq, ws)
 }
 
@@ -568,9 +574,95 @@ def private moe_gpu_gather_stack_q8n(t : Model; woff : int64; n, rows, slice_row
     if (vk_bake_slice(t, 6, woff, n, rows, wq, no_ws)) {
         return
     }
+    if (t.planes_trimmed) {
+        panic("dasLLAMA: planes_trimmed image — live gather impossible (baked plan diverged, or a re-gather was requested); rebake without --trim or match the image's config")
+    }
     invoke(g_layout_gather_q8n, t, woff, n, rows, slice_rows, mr, kgroup, wbias, wq)
 }
 
+//! P3 trim (generate-then-free): pack the emb/cls region into embq/embs, mark the model
+//! trimmed, and FREE the big CPU weight families — the save then writes them as empty planes.
+//! Arena-only plans qualify (pure resident-driver dense); false = declined, nothing changed.
+def trim_model_planes(var t : Model) : bool {
+    if (empty(t.vkplan) || t.config.n_layer_nextn > 0l) {
+        return false
+    }
+    for (e in t.vkplan) {
+        if (e.role != int(VkBakeRole.arena)) {
+            to_log(LOG_WARNING, "dasLLAMA trim: baked plan carries non-arena role {e.role} — only pure resident-driver dense models trim; declining\n")
+            return false
+        }
+    }
+    let dim = t.config.dim
+    let vocab = t.config.vocab_size
+    if (t.cls_q8) {
+        // mblob-style 34B interleaved blocks over the emb region (dequant_embq_row's layout)
+        let nb = vocab * dim / 32l
+        t.embq |> resize(int(nb * 34l))
+        unsafe {
+            for (b in range64(nb)) {
+                let off = t.emb_q8_off + b * 32l
+                var bp = addr(t.embq[b * 34l])
+                let sc = t.wscale_f16 ? uint(t.qscales16[off / 32l]) : f32_to_f16(t.qscales[off / 32l])
+                bp[0] = uint8(sc & 0xFFu)
+                bp[1] = uint8((sc >> 8u) & 0xFFu)
+                memcpy(addr<void?>(t.embq[b * 34l + 2l]), addr<void?>(t.qblob[off]), 32l)
+            }
+        }
+    } elif (cls_kq(t)) {
+        // the region's plane pair verbatim (repack layout preserved), rebased to superblock 0
+        let nsb = vocab * (dim / 256l)
+        let sb0 = t.wcls_off / 256l
+        unsafe {
+            if (t.emb_fmt == KqFmt.k4) {
+                t.embq |> resize(int(nsb * K4_QSB))
+                t.embs |> resize(int(nsb * K4_SSB))
+                memcpy(addr<void?>(t.embq[0]), addr<void?>(t.k4q[sb0 * K4_QSB]), nsb * K4_QSB)
+                memcpy(addr<void?>(t.embs[0]), addr<void?>(t.k4s[sb0 * K4_SSB]), nsb * K4_SSB)
+            } elif (t.emb_fmt == KqFmt.k5) {
+                t.embq |> resize(int(nsb * K5_QSB))
+                t.embs |> resize(int(nsb * K5_SSB))
+                memcpy(addr<void?>(t.embq[0]), addr<void?>(t.k5q[sb0 * K5_QSB]), nsb * K5_QSB)
+                memcpy(addr<void?>(t.embs[0]), addr<void?>(t.k5s[sb0 * K5_SSB]), nsb * K5_SSB)
+            } elif (t.emb_fmt == KqFmt.k6) {
+                t.embq |> resize(int(nsb * K6_QSB))
+                t.embs |> resize(int(nsb * K6_SSB))
+                memcpy(addr<void?>(t.embq[0]), addr<void?>(t.k6q[sb0 * K6_QSB]), nsb * K6_QSB)
+                memcpy(addr<void?>(t.embs[0]), addr<void?>(t.k6s[sb0 * K6_SSB]), nsb * K6_SSB)
+            } elif (t.emb_fmt == KqFmt.q40) {
+                t.embq |> resize(int(nsb * Q40_QSB))
+                t.embs |> resize(int(nsb * Q40_SSB))
+                memcpy(addr<void?>(t.embq[0]), addr<void?>(t.q40q[sb0 * Q40_QSB]), nsb * Q40_QSB)
+                memcpy(addr<void?>(t.embs[0]), addr<void?>(t.q40s[sb0 * Q40_SSB]), nsb * Q40_SSB)
+            } else {
+                to_log(LOG_WARNING, "dasLLAMA trim: emb fmt '{t.emb_fmt}' has no kq plane pair — declining\n")
+                return false
+            }
+        }
+    }   // fp32 embeddings ride fblob, which the trim keeps
+    t.planes_trimmed = true
+    delete t.qblob
+    delete t.qscales
+    delete t.qscales16
+    delete t.wblob
+    delete t.bf16blob
+    delete t.k4q
+    delete t.k4s
+    delete t.k5q
+    delete t.k5s
+    delete t.k6q
+    delete t.k6s
+    delete t.q40q
+    delete t.q40s
+    delete t.q51q
+    delete t.q51s
+    delete t.mxq
+    delete t.mxs
+    delete t.q4blob
+    delete t.q4scales
+    return true
+}
+
 def register_batch_decode_override(name : string; fn : BatchDecodeOverrideFn) {
     g_batch_decode_overrides[name] = fn
 }
@@ -797,6 +889,9 @@ struct Model {
     // scale strips, k6s the GPU split form. CPU inference on a blob-only model PANICS.
     mblob : array<uint8>
     metal_blob : bool = false
+    // P3-trimmed image: the big CPU weight families are EMPTY (GPU-resident consumers only);
+    // embed reads embq/embs, re-gathers must slice from vkblob, CPU fallbacks fail closed
+    planes_trimmed : bool = false
     q4blob : array<uint8>
     q4scales : array<float>
     // Native-MXFP4 expert stacks (valid when experts_mx4): the routed we1/we2/we3 stacks live here
@@ -952,6 +1047,11 @@ struct Model {
     // views on a flavor load — the generic finalizer walk covers both.
     vkblob : array<uint8>
     vkplan : array<VkPlanEntry>
+    // trimmed-flavor embedding planes (P3): the emb/cls tensor's rows kept CPU-readable after
+    // the big weight families drop. q8: mblob-style 34B interleaved blocks (embs empty);
+    // kq: the region's quant + scale planes copied verbatim (repack layout preserved, rebased to 0).
+    embq : array<uint8>
+    embs : array<uint8>
     // prepared-model image backing (dasllama_image): when set, every locked array field above
     // is a borrowed VIEW into this mapping (zero-copy) and the finalizer below unmaps it.
     // Both fields are skipped by the image save/load field walk.
@@ -8861,13 +8961,33 @@ def private dequant_q8_row(t : Model; off, n : int64; var dst : float?) {
     }
 }
 
+// trimmed-flavor q8 embedding read: embq holds the emb region as mblob-style 34B interleaved
+// blocks (f16 scale + 32 int8), region-rebased — same loop as dequant_q8_row's mblob arm
+def private dequant_embq_row(t : Model; off, n : int64; var dst : float?) {
+    unsafe {
+        let bp = addr < uint8 const? >(t.embq[(off / 32l) * 34l])
+        for (b in range64(n / 32l)) {
+            let sc = f16_to_f32(uint(bp[b * 34l]) | (uint(bp[b * 34l + 1l]) << 8u))
+            let qp = reinterpret<int8 const?>(bp + b * 34l + 2l)
+            let base = b * 32l
+            for (k in range64(32l)) {
+                dst[base + k] = float(qp[k]) * sc
+            }
+        }
+    }
+}
+
 // Copy token `token`'s embedding row into dst — from fp32 fblob, or (cls_q8) dequanted from the
-// linear Q8 copy at emb_q8_off, or (cls_kq) from the K-quant plane at wcls_off. Rows are whole
-// superblocks (dim % 256 == 0, a ggml K-quant invariant).
+// linear Q8 copy at emb_q8_off (embq when trimmed), or (cls_kq) from the K-quant plane at
+// wcls_off (embq/embs when trimmed). Rows are whole superblocks (a ggml K-quant invariant).
 def private embed_row(t : Model; token : int64; var dst : float?) {
     let dim = t.config.dim
     if (t.cls_q8) {
-        dequant_q8_row(t, t.emb_q8_off + token * dim, dim, dst)
+        if (t.planes_trimmed) {
+            dequant_embq_row(t, token * dim, dim, dst)
+        } else {
+            dequant_q8_row(t, t.emb_q8_off + token * dim, dim, dst)
+        }
     } elif (cls_kq(t)) {
         let mr = (t.emb_fmt == KqFmt.k4 ? t.kq_repack_mr4
             : (t.emb_fmt == KqFmt.k5 ? t.kq_repack_mr5
@@ -8878,15 +8998,29 @@ def private embed_row(t : Model; token : int64; var dst : float?) {
                 let nsb = dim / 256l
                 let g = token / mr
                 let fmt = int64(kq_fi(t.emb_fmt))
-                let sb0t = t.wcls_off / 256l
-                if (t.emb_fmt == KqFmt.k4) {
-                    dequant_kq_row_grp(fmt, addr(t.k4q[(sb0t + g * mr * nsb) * K4_QSB]), addr(t.k4s[(sb0t + g * mr * nsb) * K4_SSB]), token % mr, mr, dim, dst)
+                // trimmed: embq/embs hold the region's plane pair verbatim, rebased to 0
+                let sb0t = t.planes_trimmed ? 0l : t.wcls_off / 256l
+                let sbg = (sb0t + g * mr * nsb)
+                if (t.planes_trimmed) {
+                    if (t.emb_fmt == KqFmt.k4) {
+                        dequant_kq_row_grp(fmt, addr(t.embq[sbg * K4_QSB]), addr(t.embs[sbg * K4_SSB]), token % mr, mr, dim, dst)
+                    } elif (t.emb_fmt == KqFmt.k5) {
+                        dequant_kq_row_grp(fmt, addr(t.embq[sbg * K5_QSB]), addr(t.embs[sbg * K5_SSB]), token % mr, mr, dim, dst)
+                    } elif (t.emb_fmt == KqFmt.k6) {
+                        dequant_kq_row_grp(fmt, addr(t.embq[sbg * K6_QSB]), addr(t.embs[sbg * K6_SSB]), token % mr, mr, dim, dst)
+                    } elif (t.emb_fmt == KqFmt.q40) {
+                        dequant_kq_row_grp(fmt, addr(t.embq[sbg * Q40_QSB]), addr(t.embs[sbg * Q40_SSB]), token % mr, mr, dim, dst)
+                    } else {
+                        panic("embed_row: '{t.emb_fmt}' has no kq plane pair")
+                    }
+                } elif (t.emb_fmt == KqFmt.k4) {
+                    dequant_kq_row_grp(fmt, addr(t.k4q[sbg * K4_QSB]), addr(t.k4s[sbg * K4_SSB]), token % mr, mr, dim, dst)
                 } elif (t.emb_fmt == KqFmt.k5) {
-                    dequant_kq_row_grp(fmt, addr(t.k5q[(sb0t + g * mr * nsb) * K5_QSB]), addr(t.k5s[(sb0t + g * mr * nsb) * K5_SSB]), token % mr, mr, dim, dst)
+                    dequant_kq_row_grp(fmt, addr(t.k5q[sbg * K5_QSB]), addr(t.k5s[sbg * K5_SSB]), token % mr, mr, dim, dst)
                 } elif (t.emb_fmt == KqFmt.k6) {
-                    dequant_kq_row_grp(fmt, addr(t.k6q[(sb0t + g * mr * nsb) * K6_QSB]), addr(t.k6s[(sb0t + g * mr * nsb) * K6_SSB]), token % mr, mr, dim, dst)
+                    dequant_kq_row_grp(fmt, addr(t.k6q[sbg * K6_QSB]), addr(t.k6s[sbg * K6_SSB]), token % mr, mr, dim, dst)
                 } elif (t.emb_fmt == KqFmt.q40) {
-                    dequant_kq_row_grp(fmt, addr(t.q40q[(sb0t + g * mr * nsb) * Q40_QSB]), addr(t.q40s[(sb0t + g * mr * nsb) * Q40_SSB]), token % mr, mr, dim, dst)
+                    dequant_kq_row_grp(fmt, addr(t.q40q[sbg * Q40_QSB]), addr(t.q40s[sbg * Q40_SSB]), token % mr, mr, dim, dst)
                 } else {
                     panic("embed_row: '{t.emb_fmt}' has no kq plane pair")
                 }
@@ -8894,12 +9028,25 @@ def private embed_row(t : Model; token : int64; var dst : float?) {
         } else {
             unsafe {
                 var row = temp_array(dst, dim, type<float>)
-                let sb0 = (t.wcls_off + token * dim) / 256l
+                // trimmed: embq/embs hold the region's plane pair verbatim, rebased to 0
+                let sb0 = t.planes_trimmed ? (token * dim) / 256l : (t.wcls_off + token * dim) / 256l
                 // metal-blob planes: k4/k5 strips are 16B, k6 is the split GPU form (d in the tail)
                 let ssb45 = t.metal_blob ? 16l : K4_SSB
                 let k6d0 = t.metal_blob ? (long_length(t.k6s) / K6_SSB) * 16l : 0l
                 for (s in range64(dim / 256l)) {
-                    if (t.emb_fmt == KqFmt.k4) {
+                    if (t.planes_trimmed) {
+                        if (t.emb_fmt == KqFmt.k4) {
+                            dequant_k4_plane_superblock(t.embq, (sb0 + s) * K4_QSB, t.embs, (sb0 + s) * K4_SSB, row, s * 256l)
+                        } elif (t.emb_fmt == KqFmt.k5) {
+                            dequant_k5_plane_superblock(t.embq, (sb0 + s) * K5_QSB, t.embs, (sb0 + s) * K5_SSB, row, s * 256l)
+                        } elif (t.emb_fmt == KqFmt.k6) {
+                            dequant_k6_plane_superblock(t.embq, (sb0 + s) * K6_QSB, t.embs, (sb0 + s) * K6_SSB, row, s * 256l)
+                        } elif (t.emb_fmt == KqFmt.q40) {
+                            dequant_q40_plane_superblock(t.embq, (sb0 + s) * Q40_QSB, t.embs, (sb0 + s) * Q40_SSB, row, s * 256l)
+                        } else {
+                            panic("embed_row: '{t.emb_fmt}' has no kq plane pair")
+                        }
+                    } elif (t.emb_fmt == KqFmt.k4) {
                         dequant_k4_plane_superblock(t.k4q, (sb0 + s) * K4_QSB, t.k4s, (sb0 + s) * ssb45, row, s * 256l)
                     } elif (t.emb_fmt == KqFmt.k5) {
                         dequant_k5_plane_superblock(t.k5q, (sb0 + s) * K5_QSB, t.k5s, (sb0 + s) * ssb45, row, s * 256l)
@@ -8928,6 +9075,10 @@ def private embed_row(t : Model; token : int64; var dst : float?) {
 def private mm_cls(var y : array<float>; t : Model; x : array<float>; var xq : array<int8>; var xs : array<float>; var xbs : array<int>; n, d : int64) {
     let cls_fmt = t.config.shared_weights ? t.emb_fmt : t.wcls_fmt
     let tied_f32 = t.config.shared_weights && !t.cls_q8 && cls_fmt == KqFmt.q8
+    if (t.planes_trimmed && !moe_gpu_cls_on_gpu(t.wcls_off)) {
+        // fail closed LOUDLY: the CPU classifier path reads the trimmed families
+        panic("dasLLAMA: planes_trimmed image — the classifier must serve on the GPU (rebake without trim, or arm the tier as the image's config says)")
+    }
     if (moe_gpu_cls_on_gpu(t.wcls_off)) {
         if (cls_fmt == KqFmt.q8) {
             quantize_q8_0_into(x, n, xq, xs, 0l, 0l)
diff --git a/modules/dasLLAMA/dasllama/dasllama_config.das b/modules/dasLLAMA/dasllama/dasllama_config.das
index b78f1c7a67..35c773874f 100644
--- a/modules/dasLLAMA/dasllama/dasllama_config.das
+++ b/modules/dasLLAMA/dasllama/dasllama_config.das
@@ -51,6 +51,7 @@ struct public DlimVulkanConfig {
     dense : bool
     dense_attn : bool
     dense_shexp : bool
+    trim : bool   //!< P3: big CPU weight families dropped from the image (GPU-resident consumers only)
     subgroup_size : int
     max_storage_range : int64
 }
@@ -132,7 +133,7 @@ def public dlim_vulkan_tag(v : DlimVulkanConfig) : string {
     return ("vulkan|m{v.coopmat_mode}{v.expert_q8n ? "n" : ""} b{v.vram_mb}"
         + " l{v.moe_layers} s{v.moe_stream}"
         + " r{v.dn ? 1 : 0}{v.attn ? 1 : 0}{v.dnd ? 1 : 0}{v.shexp ? 1 : 0}{v.qkv ? 1 : 0}{v.cls ? 1 : 0}"
-        + "{v.dense ? 1 : 0}{v.dense_attn ? 1 : 0}{v.dense_shexp ? 1 : 0}")
+        + "{v.dense ? 1 : 0}{v.dense_attn ? 1 : 0}{v.dense_shexp ? 1 : 0}{v.trim ? " T" : ""}")
 }
 
 //! Round-trip: the JSON embedded in the image meta and consumed by `dasllama-convert --config`.
diff --git a/modules/dasLLAMA/dasllama/dasllama_env.das b/modules/dasLLAMA/dasllama/dasllama_env.das
index 0f2f053267..4bdce64f8d 100644
--- a/modules/dasLLAMA/dasllama/dasllama_env.das
+++ b/modules/dasLLAMA/dasllama/dasllama_env.das
@@ -229,6 +229,8 @@ def private reg_vulkan(var o : array<EnvKnob>) {
       "Fused decode tail (add+rms+requant, qk-norm+rope); 0 pins the split dispatches for a same-build A/B.")
     k(o, "DASLLAMA_VK_XFERQ", EnvKind.flag, EnvArea.vulkan, "on",
       "Stream expert uploads on the dedicated transfer queue, overlapped via a timeline semaphore; 0 keeps the single-queue rail.")
+    k(o, "DASLLAMA_TRIM", EnvKind.flag, EnvArea.vulkan, "off",
+      "Serve from P3-trimmed vulkan images (big CPU weight families dropped; folded into the flavor identity).")
     k(o, "DASLLAMA_VK_MEMPRIO", EnvKind.flag, EnvArea.vulkan, "on",
       "Tag allocations high-priority (VK_EXT_memory_priority) so the driver demotes desktop memory, not ours.")
     k(o, "DASLLAMA_VK_FA", EnvKind.flag, EnvArea.vulkan, "on",
diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index 23fb762a39..fa492a0407 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -311,6 +311,7 @@ def private serialize_image_meta(var arch : Archive; var t : Model) {
     arch |> serialize_raw(t.ple_post_off)
     arch |> serialize_raw(t.wscale_f16)
     arch |> serialize_raw(t.metal_blob)
+    arch |> serialize_raw(t.planes_trimmed)
     arch |> serialize_raw(t.experts_mx4)
     arch |> serialize_raw(t.ple_model_bf16)
     arch |> serialize_raw(t.kquant_native)
@@ -358,9 +359,9 @@ def private serialize_image_meta(var arch : Archive; var t : Model) {
     arch |> serialize_raw(t.mtp_headnorm_off)
 }
 
-// the tripwire: serialize_image_meta(Model) covers 65 fields; blocks + image_map +
+// the tripwire: serialize_image_meta(Model) covers 66 fields; blocks + image_map +
 // image_bytes are deliberate skips. A new non-array Model field trips this until BOTH agree.
-let IMAGE_META_FIELDS = 65 + 3
+let IMAGE_META_FIELDS = 66 + 3
 
 //! Count of meta-carried fields of any struct: non-arrays plus string arrays (those cannot
 //! be raw planes — see serialize_strings). Pair with a per-type field-count constant to
diff --git a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
index cc9cd3760a..2ec036b588 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
@@ -4423,6 +4423,7 @@ def private vk_dlim_wants_fill(var v : DlimVulkanConfig) {
     v.dense = gpu_want_dense()
     v.dense_attn = gpu_want_dense_attn()
     v.dense_shexp = gpu_want_dense_shexp()
+    v.trim = env_flag("DASLLAMA_TRIM", false)
 }
 
 //! Arm the tier for an OFFLINE bake: the load walk runs its full accept/refuse arithmetic
@@ -4433,6 +4434,7 @@ def vulkan_dry_bake_arm(v : DlimVulkanConfig) : bool {
     // them would write an image whose identity lies about its own plan. Fail closed, name both.
     var w = v
     vk_dlim_wants_fill(w)
+    w.trim = v.trim   // trim shapes the SAVE, not the walk — the converter's flag decides it
     if (dlim_vulkan_tag(w) != dlim_vulkan_tag(v)) {
         to_log(LOG_ERROR, "dasLLAMA vulkan tier: dry-bake config disagrees with this process' wants (set the DASLLAMA_GPU_* knobs to match)\n  config {dlim_vulkan_tag(v)}\n  wants  {dlim_vulkan_tag(w)}\n")
         return false
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 09b0326489..3cde0c89ef 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -64,6 +64,9 @@ struct ConvertArgs {
     @clarg_doc = "Print this box's DlimConfiguration JSON (or write it to -o) and exit"
     dump_config : bool
 
+    @clarg_doc = "P3 trim (with -f vulkan): drop the big CPU weight families from the image — pure resident-driver dense models only; serve with DASLLAMA_TRIM=1"
+    trim : bool
+
     @clarg_doc = "Convert even if a valid image is already there (default: report it and exit 0)"
     force : bool
 
@@ -228,6 +231,10 @@ def main() : int {
         }
         have_want = true
     }
+    if (cfg.trim && cfg.flavor != Flavor.vulkan) {
+        to_log(LOG_ERROR, "dasllama-convert: --trim is a vulkan-flavor property (add -f vulkan)\n")
+        return 2
+    }
     if (cfg.flavor == Flavor.vulkan) {
         // OFFLINE bake: the walk's accept/refuse arithmetic runs against the config's numbers,
         // the gathers collect, and no Vulkan call is made — no instance, no device, no VRAM
@@ -242,6 +249,7 @@ def main() : int {
             }
             vkc = probed.vulkan
         }
+        vkc.trim = cfg.trim
         if (!moe_gpu_dry_bake_arm(vkc)) {
             to_log(LOG_ERROR, "dasllama-convert: offline vulkan bake could not arm — see the log above\n")
             return 2
@@ -281,6 +289,10 @@ def main() : int {
             to_log(LOG_ERROR, "dasllama-convert: the GPU walk collected nothing — the tier declined this model under the supplied config\n")
             rc = 1
         }
+        if (rc == 0 && cfg.trim && !trim_model_planes(m)) {
+            to_log(LOG_ERROR, "dasllama-convert: --trim declined — see the log above (only pure resident-driver dense models qualify)\n")
+            rc = 1
+        }
         if (rc == 0 && !save_model_image(m, out, tag, qs)) {
             to_log(LOG_ERROR, "dasllama-convert: writing '{out}' failed — see the error above\n")
             rc = 1

From e0b572ab210c3b7112a43d6d9533985189a9ca0d Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 23:19:50 -0700
Subject: [PATCH 08/30] dlim arc phase C gates: trim decode parity EXACT;
 re-bind slices; trimmed CPU fallback fails closed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The C decode gate PASSED at the strongest level: Qwen3-4B Q8_0, resident-driver rail (f32-KV
session), 24 greedy tokens — trimmed image vs untrimmed image IDS are token-for-token IDENTICAL
(the embq read path serves every embed). The trimmed Q8 image is 4475 MB vs ~8.5 GB untrimmed.

blob_only_panic grows a planes_trimmed arm — all six CPU fall-through sites (decode/prefill/
batch-decode stacks + their cls steps) now fail closed with an actionable message (the
commonest trigger: a non-f32-KV session makes the resident overrides decline, e.g.
create_session's f16 default). dasllama-server's bind_gpu_slot re-binds a vulkan-flavor slot
by SLICING its baked planes (same rail as its load) — on a trimmed image a live re-gather
would panic, and on any flavor image the slice replaces redundant re-gather work.

KNOWN PRE-EXISTING (not this arc): Qwen3-4B Q4_K_M on the resident rail generates all-zero
IDS (logits degenerate) — reproduced on an UNTRIMMED image and matching the banked
_vk_prefill_parity degeneracy note; Q4_K_M therefore cannot gate end-to-end decode either way.
Rode along: the 5 pre-existing LINT017s in openai_server.das (int64(length) -> long_length).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_common.das |  4 ++++
 utils/dasllama-server/openai_server.das       | 20 +++++++++++++------
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index ade76d34bf..4c3b9c35d6 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -734,6 +734,10 @@ def private blob_only_panic(t : Model; what : string) {
     if (t.metal_blob) {
         panic("dasLLAMA: CPU {what} on a blob-only metal-flavor model — serve it on the GPU (set_metal_mode / fix the declined gate) or load the CPU-flavor image (metal mode off at load_model)")
     }
+    if (t.planes_trimmed) {
+        // the resident overrides need an f32-KV session — the commonest decline on a trimmed image
+        panic("dasLLAMA: CPU {what} on a planes-trimmed vulkan-flavor image — the resident driver must serve it (create the session with KVDtype.f32, keep the tier armed) or rebake without --trim")
+    }
 }
 
 def has_decode_override(name : string) : bool {
diff --git a/utils/dasllama-server/openai_server.das b/utils/dasllama-server/openai_server.das
index 8752c581d0..ec8910290a 100644
--- a/utils/dasllama-server/openai_server.das
+++ b/utils/dasllama-server/openai_server.das
@@ -238,7 +238,15 @@ def private bind_gpu_slot(si : int) {
     install_slot_marks(si)
     set_gpu_tier_want(g_slots[si].gpu_want)
     moe_gpu_tier_arm()
-    moe_gpu_upload_resident(g_slots[si].model)
+    // a vulkan-flavor image re-binds by SLICING its baked planes (the same rail its load used);
+    // on a planes-trimmed image a live re-gather would panic — the slice is the only path
+    if (!empty(g_slots[si].model.vkplan)) {
+        vulkan_bake_slice_begin()
+        moe_gpu_upload_resident(g_slots[si].model)
+        vulkan_bake_slice_end(g_slots[si].model)
+    } else {
+        moe_gpu_upload_resident(g_slots[si].model)
+    }
     g_gpu_owner = si
     let us = int64(get_time_usec(t0))
     g_slots[si].sw_count ++
@@ -1206,7 +1214,7 @@ def private handle_embeddings(var req : HttpRequest?; var resp : HttpResponse?)
     var idx = 0
     for (text in inputs) {
         let toks <- encode(cur_model(), text, true, false)
-        prompt_tokens += int64(length(toks))
+        prompt_tokens += long_length(toks)
         var vec = embed(cur_model(), text)
         out.data |> emplace(OaiEmbedding(_object = "embedding", embedding <- vec, index = idx))
         idx ++
@@ -1287,7 +1295,7 @@ def private register_request(srv : WebSocketServer; var writer : HttpResponseWri
                              streaming, is_chat : bool; prefix : string;
                              tools_declared : bool = false; call_open : string = ""; call_close : string = "";
                              seed : int = 0) {
-    let np = int64(length(prompt))
+    let np = long_length(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
@@ -1539,7 +1547,7 @@ def private handle_chat(srv : WebSocketServer; var req : HttpRequest?; var write
             bad_request(srv, writer, render_error)
             return
         }
-        let required = int64(length(prompt)) + (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
         }
@@ -1931,7 +1939,7 @@ def private handle_streams(var resp : HttpResponse?) : http_status {
                 id = st.id, model = mname,
                 state = st.state == StreamState.prefilling ? "prefilling" : "decoding",
                 age_s = age_seconds(st.t_admit),
-                n_prompt = int64(length(st.prompt)), 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))))
@@ -1940,7 +1948,7 @@ def private handle_streams(var resp : HttpResponse?) : 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 = int64(length(q.prompt)), 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(

From e90bdecae1914111fafa005e8fcd8c76a32e3643 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 23:35:54 -0700
Subject: [PATCH 09/30] =?UTF-8?q?dlim=20arc=20phase=20E:=20prefetch=5Fmap?=
 =?UTF-8?q?=20=E2=80=94=20advisory=20source=20readahead,=20with=20tests=20?=
 =?UTF-8?q?and=20docs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New fio builtin `prefetch_map(base, bytes)`: PrefetchVirtualMemory on Windows,
madvise(MADV_WILLNEED) on POSIX — ask the OS to fault a mapped range in AHEAD of a parallel
pass (on-demand faults inside the transcode lanes serialize them; the banked cold-conversion
gap is 9x on Q4_K source). Advisory by contract: false = the OS declined, reads still work.

The gguf loader arms it over the whole source mapping (both the single-file fmap and the
split-shard rail) behind the new DASLLAMA_PREFETCH knob (default on, =0 restores on-demand
faulting for the A/B; registered, ENVIRONMENT.md regenerated) and logs one
"source prefetch armed (N MB)" proof-of-engagement line.

Ships with its contract test (tests/fio/fio_prefetch.das — acceptance over a real fmap,
content intact after the advise, degenerate-argument decline; 3/3) and docs: handmade RST for
prefetch_map plus the six dwrite_* functions (which shipped bare in 8cb3a8b4f), and a
"Direct IO and mapping advice" group in das2rst so none of them render as Uncategorized.
The judged cold-conversion A/B waits for the quiet box; the engagement smoke passes warm.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 doc/reflections/das2rst.das                   |  1 +
 ...n-fio-dwrite_append-0x6658e660a37b258d.rst |  1 +
 ...ion-fio-dwrite_band-0x160228ade96e97be.rst |  1 +
 ...ion-fio-dwrite_close-0xca8d8214309caf7.rst |  1 +
 ...n-fio-dwrite_commit-0x122d2094a7b99d77.rst |  1 +
 ...ion-fio-dwrite_open-0x46f123a0dc4b0ce0.rst |  1 +
 ...ion-fio-dwrite_stat-0xbf270ab2cb2df9d6.rst |  1 +
 ...on-fio-prefetch_map-0xc63f5d4e91b2e653.rst |  1 +
 include/daScript/simulate/aot_builtin_fio.h   |  1 +
 modules/dasLLAMA/ENVIRONMENT.md               |  1 +
 modules/dasLLAMA/dasllama/dasllama_common.das | 21 +++++++
 modules/dasLLAMA/dasllama/dasllama_env.das    |  2 +
 src/builtin/module_builtin_fio.cpp            | 36 +++++++++++
 tests/fio/fio_prefetch.das                    | 59 +++++++++++++++++++
 14 files changed, 128 insertions(+)
 create mode 100644 doc/source/stdlib/handmade/function-fio-dwrite_append-0x6658e660a37b258d.rst
 create mode 100644 doc/source/stdlib/handmade/function-fio-dwrite_band-0x160228ade96e97be.rst
 create mode 100644 doc/source/stdlib/handmade/function-fio-dwrite_close-0xca8d8214309caf7.rst
 create mode 100644 doc/source/stdlib/handmade/function-fio-dwrite_commit-0x122d2094a7b99d77.rst
 create mode 100644 doc/source/stdlib/handmade/function-fio-dwrite_open-0x46f123a0dc4b0ce0.rst
 create mode 100644 doc/source/stdlib/handmade/function-fio-dwrite_stat-0xbf270ab2cb2df9d6.rst
 create mode 100644 doc/source/stdlib/handmade/function-fio-prefetch_map-0xc63f5d4e91b2e653.rst
 create mode 100644 tests/fio/fio_prefetch.das

diff --git a/doc/reflections/das2rst.das b/doc/reflections/das2rst.das
index ea4de0519b..1b8cd7236c 100644
--- a/doc/reflections/das2rst.das
+++ b/doc/reflections/das2rst.das
@@ -215,6 +215,7 @@ def document_module_fio(_root : string) {
     var mod = [get_module("fio_core"), find_module("fio")]
     var groups <- array<DocGroup>(
         hide_group(group_by_regex("Internal builtin functions", mod, %regex~builtin%%)),
+        group_by_regex("Direct IO and mapping advice", mod, %regex~(dwrite_open|dwrite_append|dwrite_band|dwrite_commit|dwrite_stat|dwrite_close|prefetch_map)$%%),
         group_by_regex("File manipulation", mod, %regex~(f|long_f|stat$|getchar|remove|rename|copy_file|file_size|equivalent|is_symlink|set_mtime)%%),
         group_by_regex("Path manipulation", mod, %regex~(base_name|dir_name|get_full_file_name|extension|stem|replace_extension|path_join|normalize|to_generic_path|is_absolute|relative|relative_result|parent)$%%),
         group_by_regex("Directory manipulation", mod, %regex~(dir|dir_rec|mkdir|mkdir_rec|mkdir_result|rmdir|rmdir_rec|rmdir_rec_result|rmdir_result|chdir|getcwd)$%%),
diff --git a/doc/source/stdlib/handmade/function-fio-dwrite_append-0x6658e660a37b258d.rst b/doc/source/stdlib/handmade/function-fio-dwrite_append-0x6658e660a37b258d.rst
new file mode 100644
index 0000000000..e5048ab537
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-dwrite_append-0x6658e660a37b258d.rst
@@ -0,0 +1 @@
+Append ``bytes`` from ``data`` at the writer's current end. Any pointer, any size — the handle re-blocks into aligned bands internally, and a band-multiple, band-aligned source is written directly with no copy. Returns false when a write fails (disk full, in practice); a failed writer stays failed, so checking ``dwrite_close`` once is enough.
diff --git a/doc/source/stdlib/handmade/function-fio-dwrite_band-0x160228ade96e97be.rst b/doc/source/stdlib/handmade/function-fio-dwrite_band-0x160228ade96e97be.rst
new file mode 100644
index 0000000000..0873f25091
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-dwrite_band-0x160228ade96e97be.rst
@@ -0,0 +1 @@
+Hand out the writer's own staging band so a producer can build bytes in place instead of building a buffer and appending a copy. ``avail`` receives the free space left in the current band; fill up to that many bytes and account for them with ``dwrite_commit``. Returns null on a dead writer.
diff --git a/doc/source/stdlib/handmade/function-fio-dwrite_close-0xca8d8214309caf7.rst b/doc/source/stdlib/handmade/function-fio-dwrite_close-0xca8d8214309caf7.rst
new file mode 100644
index 0000000000..ee9291a4e0
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-dwrite_close-0xca8d8214309caf7.rst
@@ -0,0 +1 @@
+Flush the writer's tail (sector-padded on cache-bypassing platforms), truncate the file to exactly what was appended, and free the handle. Returns false if anything failed anywhere along the writer's life — this is the one completion verdict a caller needs to check.
diff --git a/doc/source/stdlib/handmade/function-fio-dwrite_commit-0x122d2094a7b99d77.rst b/doc/source/stdlib/handmade/function-fio-dwrite_commit-0x122d2094a7b99d77.rst
new file mode 100644
index 0000000000..8be300795a
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-dwrite_commit-0x122d2094a7b99d77.rst
@@ -0,0 +1 @@
+Account ``bytes`` written into the pointer ``dwrite_band`` handed out; a full band flushes to the device automatically. Returns false when the commit overruns the band's remaining space (a producer bug) or the writer already failed.
diff --git a/doc/source/stdlib/handmade/function-fio-dwrite_open-0x46f123a0dc4b0ce0.rst b/doc/source/stdlib/handmade/function-fio-dwrite_open-0x46f123a0dc4b0ce0.rst
new file mode 100644
index 0000000000..7a4de5fa46
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-dwrite_open-0x46f123a0dc4b0ce0.rst
@@ -0,0 +1 @@
+Open ``path`` for cache-bypassing sequential append (``FILE_FLAG_NO_BUFFERING`` on Windows, ``F_NOCACHE`` on macOS, ``posix_fallocate`` plus ``fadvise`` elsewhere). ``total_bytes`` preallocates the file — writes must then be strictly ascending, which is what avoids NTFS valid-data-length zero-fill; the file is truncated back to what was actually appended at close. ``band_bytes`` sizes the internal sector-aligned bounce buffer (16 MB when in doubt). Returns null on failure. Pair with ``dwrite_append`` or the ``dwrite_band``/``dwrite_commit`` producer surface, and always finish with ``dwrite_close``.
diff --git a/doc/source/stdlib/handmade/function-fio-dwrite_stat-0xbf270ab2cb2df9d6.rst b/doc/source/stdlib/handmade/function-fio-dwrite_stat-0xbf270ab2cb2df9d6.rst
new file mode 100644
index 0000000000..a6b75d743d
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-dwrite_stat-0xbf270ab2cb2df9d6.rst
@@ -0,0 +1 @@
+Where the writer spent its time so far: ``which`` 0 = staging nanoseconds (memcpy into the bounce band), 1 = syscall nanoseconds, 2 = bytes written directly from caller memory, 3 = bytes that went through the bounce band. Call before ``dwrite_close`` — the handle is gone after.
diff --git a/doc/source/stdlib/handmade/function-fio-prefetch_map-0xc63f5d4e91b2e653.rst b/doc/source/stdlib/handmade/function-fio-prefetch_map-0xc63f5d4e91b2e653.rst
new file mode 100644
index 0000000000..8ade89dd63
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-prefetch_map-0xc63f5d4e91b2e653.rst
@@ -0,0 +1 @@
+Advisory readahead over a mapped range: asks the OS to fault ``bytes`` starting at ``base`` into the page cache ahead of use (``PrefetchVirtualMemory`` on Windows, ``madvise(MADV_WILLNEED)`` on POSIX). Use it on an ``fmap``/``fmap_open`` mapping before a parallel pass over the data — on-demand faults taken inside worker lanes serialize them. Returns false when the OS declines; the call is purely advisory, so reads work either way.
diff --git a/include/daScript/simulate/aot_builtin_fio.h b/include/daScript/simulate/aot_builtin_fio.h
index acc7570cc1..17208e36e1 100644
--- a/include/daScript/simulate/aot_builtin_fio.h
+++ b/include/daScript/simulate/aot_builtin_fio.h
@@ -95,6 +95,7 @@ namespace das {
     DAS_API bool builtin_dwrite_commit ( void * h, uint64_t bytes, Context * context, LineInfoArg * at );
     DAS_API uint64_t builtin_dwrite_stat ( void * h, int32_t which, Context * context, LineInfoArg * at );
     DAS_API bool builtin_dwrite_close ( void * h, Context * context, LineInfoArg * at );
+    DAS_API bool builtin_prefetch_map ( void * base, uint64_t bytes, Context * context, LineInfoArg * at );
     DAS_API char * builtin_dirname ( const char * name, Context * context, LineInfoArg * at );
     DAS_API char * builtin_basename ( const char * name, Context * context, LineInfoArg * at );
     DAS_API bool builtin_fstat ( const FILE * f, FStat & fs, Context * context, LineInfoArg * at );
diff --git a/modules/dasLLAMA/ENVIRONMENT.md b/modules/dasLLAMA/ENVIRONMENT.md
index 80504fcf27..5b79446b69 100644
--- a/modules/dasLLAMA/ENVIRONMENT.md
+++ b/modules/dasLLAMA/ENVIRONMENT.md
@@ -46,6 +46,7 @@ Read by the inference engine itself, so these affect any program that loads a mo
 | `DASLLAMA_GPU_COMBINE` | flag | on | Device-side routed MoE combine; 0 falls back to the host combine. |
 | `DASLLAMA_GPU_HEAT` | number | 0 | Expert heat threshold: hold the N hottest experts resident regardless of layer placement. |
 | `DASLLAMA_GPU_PROF` | flag | off | Report lifetime GPU queue submissions (real commands plus staging round-trips). |
+| `DASLLAMA_PREFETCH` | flag | on | Advisory source-mapping readahead at gguf load (cold-conversion fix); =0 restores on-demand faulting. |
 
 ## Metal backend
 
diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index 4c3b9c35d6..7918766259 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -3310,6 +3310,18 @@ def private load_gguf_impl(path : string; var mode : QuantMode) : Model {
         var bases : array<void?>
         var sizes : array<int64>
         gguf_map_shards(shards, 0, bases, sizes) {
+            // fault the source in AHEAD of the parallel transcode (in-loop faults serialize lanes)
+            if (env_flag("DASLLAMA_PREFETCH", true)) {
+                var pf_mb = 0l
+                for (bi in range(length(bases))) {
+                    if (unsafe(prefetch_map(bases[bi], uint64(sizes[bi])))) {
+                        pf_mb += sizes[bi] >> 20l
+                    }
+                }
+                if (pf_mb > 0l) {
+                    to_log(LOG_INFO, "dasLLAMA: source prefetch armed ({pf_mb} MB across {length(shards)} shards)\n")
+                }
+            }
             var m <- parse_gguf_meta_shards(bases, sizes)
             unsafe {
                 load_gguf_parsed(t, m, temp_array(reinterpret<uint8?>(bases[0]), sizes[0], type<uint8>), mode, ts_load)
@@ -3326,6 +3338,15 @@ def private load_gguf_impl(path : string; var mode : QuantMode) : Model {
         panic("dasLLAMA: cannot open gguf '{path}'")
     }
     fmap(f) $(var bytes : array<uint8>#) {
+        if (env_flag("DASLLAMA_PREFETCH", true)) {
+            var armed = false
+            unsafe {
+                armed = prefetch_map(addr<void?>(bytes[0]), uint64(long_length(bytes)))
+            }
+            if (armed) {
+                to_log(LOG_INFO, "dasLLAMA: source prefetch armed ({long_length(bytes) >> 20l} MB)\n")
+            }
+        }
         var inscope m <- parse_gguf_meta(bytes)
         load_gguf_parsed(t, m, bytes, mode, ts_load)
     }
diff --git a/modules/dasLLAMA/dasllama/dasllama_env.das b/modules/dasLLAMA/dasllama/dasllama_env.das
index 4bdce64f8d..91aeeb1b47 100644
--- a/modules/dasLLAMA/dasllama/dasllama_env.das
+++ b/modules/dasLLAMA/dasllama/dasllama_env.das
@@ -229,6 +229,8 @@ def private reg_vulkan(var o : array<EnvKnob>) {
       "Fused decode tail (add+rms+requant, qk-norm+rope); 0 pins the split dispatches for a same-build A/B.")
     k(o, "DASLLAMA_VK_XFERQ", EnvKind.flag, EnvArea.vulkan, "on",
       "Stream expert uploads on the dedicated transfer queue, overlapped via a timeline semaphore; 0 keeps the single-queue rail.")
+    k(o, "DASLLAMA_PREFETCH", EnvKind.flag, EnvArea.engine, "on",
+      "Advisory source-mapping readahead at gguf load (cold-conversion fix); =0 restores on-demand faulting.")
     k(o, "DASLLAMA_TRIM", EnvKind.flag, EnvArea.vulkan, "off",
       "Serve from P3-trimmed vulkan images (big CPU weight families dropped; folded into the flavor identity).")
     k(o, "DASLLAMA_VK_MEMPRIO", EnvKind.flag, EnvArea.vulkan, "on",
diff --git a/src/builtin/module_builtin_fio.cpp b/src/builtin/module_builtin_fio.cpp
index e496332943..7965490f6c 100644
--- a/src/builtin/module_builtin_fio.cpp
+++ b/src/builtin/module_builtin_fio.cpp
@@ -54,6 +54,7 @@ void * das_dwrite_band ( void * h, uint64_t * avail );
 bool das_dwrite_commit ( void * h, uint64_t bytes );
 uint64_t das_dwrite_stat ( void * h, int which );
 bool das_dwrite_close ( void * h );
+bool das_prefetch_map ( void * base, uint64_t bytes );
 
 namespace das {
 
@@ -504,6 +505,13 @@ namespace das {
         return das_dwrite_close(h);
     }
 
+    // advisory readahead over a mapped range (PrefetchVirtualMemory / madvise WILLNEED) — the
+    // cold-conversion fix. false = the OS declined; reads still work, just cold.
+    bool builtin_prefetch_map ( void * base, uint64_t bytes, Context * context, LineInfoArg * at ) {
+        if ( !base && bytes ) context->throw_error_at(at, "prefetch_map: null base");
+        return das_prefetch_map(base, bytes);
+    }
+
     // plain ftell/fseek take `long`, which is 32-bit on Windows (LLP64) — use the explicit
     // 64-bit forms so offsets past 2GB survive on every platform
     int64_t builtin_ftell ( const FILE * f, Context * context, LineInfoArg * at ) {
@@ -2324,6 +2332,9 @@ namespace das {
             addExtern<DAS_BIND_FUN(builtin_dwrite_close)>(*this, lib, "dwrite_close",
                 SideEffects::modifyExternal, "builtin_dwrite_close")
                     ->args({"writer","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_prefetch_map)>(*this, lib, "prefetch_map",
+                SideEffects::modifyExternal, "builtin_prefetch_map")
+                    ->args({"base","bytes","context","line"})->unsafeOperation = true;
             addExtern<DAS_BIND_FUN(builtin_fgets)>(*this, lib, "fgets",
                 SideEffects::modifyExternal, "builtin_fgets")
                     ->args({"file","context","line"});
@@ -2575,6 +2586,31 @@ int munmap ( void* start, size_t ) {
 
 #endif
 
+// ===== prefetch: advisory readahead over a mapped range =====
+
+#if DAS_NO_FILEIO
+
+bool das_prefetch_map ( void *, uint64_t ) { return false; }
+
+#else
+
+// Ask the OS to fault a mapped range in AHEAD of use — the cold-read fix (on-demand page
+// faults inside a parallel transcode loop serialize the lanes; measured 9x on Q4_K source).
+// Advisory: a false return means the OS declined — reads still work, just cold.
+bool das_prefetch_map ( void * base, uint64_t bytes ) {
+    if ( !base || bytes==0 ) return false;
+#ifdef _MSC_VER
+    WIN32_MEMORY_RANGE_ENTRY range;
+    range.VirtualAddress = base;
+    range.NumberOfBytes = (SIZE_T) bytes;
+    return PrefetchVirtualMemory(GetCurrentProcess(), 1, &range, 0) != 0;
+#else
+    return madvise(base, (size_t)bytes, MADV_WILLNEED)==0;
+#endif
+}
+
+#endif
+
 // ===== dwrite: the direct sequential writer =====
 
 #if DAS_NO_FILEIO
diff --git a/tests/fio/fio_prefetch.das b/tests/fio/fio_prefetch.das
new file mode 100644
index 0000000000..67d2ca580e
--- /dev/null
+++ b/tests/fio/fio_prefetch.das
@@ -0,0 +1,59 @@
+options gen2
+require dastest/testing_boost
+require daslib/fio
+
+// prefetch_map is ADVISORY readahead — these are contract tests (acceptance + intact reads +
+// degenerate-argument declines), not timing: the OS is free to prefetch lazily or not at all.
+
+[test]
+def test_prefetch_map(t : T?) {
+    t |> run("prefetch over a real mapping is accepted and reads stay intact") @(t : T?) {
+        var terr : string
+        let tmp = temp_directory(terr)   // portable (no /tmp on Windows); cwd as a last resort
+        let fname = path_join(empty(tmp) ? "." : tmp, "fio_prefetch_{ref_time_ticks()}.bin")
+        let n = 65536
+        var payload : array<uint8>
+        payload |> resize(n)
+        for (i in range(n)) {
+            payload[i] = uint8(i % 251)
+        }
+        var wrote = false
+        fopen(fname, "wb") $(f) {
+            if (f != null) {
+                fwrite(f, payload)
+                wrote = true
+            }
+        }
+        t |> success(wrote, "wrote the probe file")
+        var mapped = false
+        fopen(fname, "rb") $(f) {
+            if (f == null) {
+                return
+            }
+            fmap(f) $(var bytes : array<uint8>#) {
+                mapped = true
+                var armed = false
+                unsafe {
+                    armed = prefetch_map(addr<void?>(bytes[0]), uint64(long_length(bytes)))
+                }
+                t |> success(armed, "the OS accepted the advisory prefetch")
+                var intact = length(bytes) == n
+                for (i in range(n)) {
+                    if (bytes[i] != uint8(i % 251)) {
+                        intact = false
+                        break
+                    }
+                }
+                t |> success(intact, "mapped content intact after prefetch")
+            }
+        }
+        t |> success(mapped, "mapped the probe file")
+        delete payload
+        remove(fname)
+    }
+    t |> run("degenerate arguments decline instead of crashing") @(t : T?) {
+        unsafe {
+            t |> success(!prefetch_map(null, 0ul), "null base + zero bytes declines")
+        }
+    }
+}

From 33220f91ee85dedc6affc6d636835c80eb2d85a2 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Mon, 27 Jul 2026 23:38:44 -0700
Subject: [PATCH 10/30] =?UTF-8?q?dlim=20arc=20phase=20D=20step=201:=20Fill?=
 =?UTF-8?q?Job=20recording=20=E2=80=94=20load=5Fbig=20grows=20an=20inert?=
 =?UTF-8?q?=20plan=20mode?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

fill_plan_begin/fill_plan_take + a FillJob record of load_big's call args (name/woff/n/
src_off/fmt). Armed, load_big appends a job and returns instead of transcoding — the ~45-call
weights walk runs UNCHANGED as the plan pass, and the fill pass will re-derive each branch by
replaying load_big's own conditions, so plan and fill cannot drift. Off by default; zero
behavior change (mechanics unchanged, compiles+lints clean). The fill executor (per-plane-
family sorted jobs, job-sized temps, fused per-region repack + wscale, dwrite_band consumers,
scale side-buffers) is the next slice per the banked design.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_common.das | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index 7918766259..756a0f805b 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -1667,7 +1667,39 @@ def conv_profile_report() {
     delete rows
 }
 
+// ===== streaming plan/fill (phase D of the .dlim arc) =====
+
+//! One recorded big-tensor conversion: load_big's call args, replayable — the fill pass
+//! re-derives the branch from (fmt, quant, disk type), so plan and fill cannot drift.
+struct FillJob {
+    name : string
+    woff : int64
+    n : int64
+    src_off : int64
+    fmt : KqFmt
+}
+
+var private g_fill_plan_mode = false
+var private g_fill_plan : array<FillJob>
+
+//! Arm plan recording: subsequent load_big calls append FillJobs instead of transcoding
+//! (smalls still load eagerly — fblob is small and every flavor keeps it).
+def fill_plan_begin {
+    g_fill_plan_mode = true
+    g_fill_plan |> clear()
+}
+
+//! Disarm and move the recorded plan out (empty = nothing recorded).
+def fill_plan_take(var out : array<FillJob>) {
+    g_fill_plan_mode = false
+    out <- g_fill_plan
+}
+
 def private load_big(m : GGUFMeta; bytes : array<uint8> | #; name : string; var t : Model; woff, n : int64; var scratch : array<float>; src_off : int64 = 0l; fmt : KqFmt = KqFmt.q8) {
+    if (g_fill_plan_mode) {
+        g_fill_plan |> push(FillJob(name = name, woff = woff, n = n, src_off = src_off, fmt = fmt))
+        return
+    }
     let t0 = g_conv_prof ? ref_time_ticks() : 0l
     var kind = "f32 read (no quant)"
     if (fmt == KqFmt.k4) {

From 074a5d81477e41bc410e8021abc0964c6949078a Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 00:23:44 -0700
Subject: [PATCH 11/30] dlim arc phase D step 2: plan-mode sizing skip, decline
 gate, tied-cls through load_big
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Under fill_plan_mode the big q-halves (qblob/k*q/q40q/q51q) are never sized — the streamed
fill writes them straight to the image — while the scale halves (6-16%) stay in RAM so the
wscale/save paths see them normally. Models with direct-write loaders (mx4 experts, grouped
deltanet, bf16 PLE, non-q8 modes) disarm the plan BEFORE sizing and convert eagerly with an
empty job list — fail-open to the correct path.

The tied-Q8 classifier/embedding double-copy now routes through load_big (its q8 arm is the
same transcode with the same offsets) so the plan records both copies. PROVEN byte-clean: a
fresh Q8_0 conversion's entire plane region [64, meta_off) — all 4.69 GB — is byte-identical
to the pre-refactor image (the file-level SHA delta is the embedded config JSON recording
GPU-armed vs unarmed box state, by design). Image mechanics+smol arms 9/9.

Still inert — nothing arms fill_plan_mode yet. Next slice: the fill executor (repack-region
enumeration seam on the walkers, per-job temp transcode replay, the save-walk hook + wscale
epilogue after qblob, the mapping-alive streaming entry, converter --stream).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_common.das | 53 +++++++++++++------
 1 file changed, 38 insertions(+), 15 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index 756a0f805b..ee772f34dc 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -3875,6 +3875,13 @@ def private load_gguf_parsed(var t : Model; m : GGUFMeta; bytes : array<uint8> |
             && gguf_tensor_type(m, "per_layer_model_proj.weight") == GGML_TYPE_BF16)
         let kv = t.config.kv_dim
         let qd = t.config.n_heads * t.config.head_size   // query width (== dim except Gemma2)
+        // streaming covers the q8-mode load_big rails; models with direct-write loaders
+        // (mx4 experts, grouped deltanet, bf16 PLE) disarm HERE — before sizing — so the
+        // eager path proceeds with fully materialized planes and an empty job list
+        if (g_fill_plan_mode && (mode != QuantMode.q8 || t.experts_mx4 || t.dn_grouped || t.ple_model_bf16)) {
+            to_log(LOG_INFO, "dasLLAMA: streaming plan disarmed — unstreamed rail (mode {mode}, mx4 {t.experts_mx4}, dn-grouped {t.dn_grouped}, bf16-ple {t.ple_model_bf16}); converting eagerly\n")
+            g_fill_plan_mode = false
+        }
         let sz = layout_offsets(t)
         // fp32 aux (embedding + norms) is always present; the big-weight storage matches `mode`
         reserve_resize(t.fblob, sz.fblob_n)
@@ -3888,39 +3895,54 @@ def private load_gguf_parsed(var t : Model; m : GGUFMeta; bytes : array<uint8> |
             t.mxs |> reserve(sz.mx_n / 32l)
             t.mxs |> resize(sz.mx_n / 32l)
         }
+        // streaming: big q-halves never materialize (jobs stream them to the writer); scale
+        // halves are small (6-16%) and stay in RAM. Unstreamable features disarmed above.
+        let stream_q = g_fill_plan_mode
         if (sz.k4_n > 0l) {
-            t.k4q |> reserve((sz.k4_n / 256l) * K4_QSB)
-            t.k4q |> resize((sz.k4_n / 256l) * K4_QSB)
+            if (!stream_q) {
+                t.k4q |> reserve((sz.k4_n / 256l) * K4_QSB)
+                t.k4q |> resize((sz.k4_n / 256l) * K4_QSB)
+            }
             t.k4s |> reserve((sz.k4_n / 256l) * K4_SSB)
             t.k4s |> resize((sz.k4_n / 256l) * K4_SSB)
         }
         if (sz.k5_n > 0l) {
-            t.k5q |> reserve((sz.k5_n / 256l) * K5_QSB)
-            t.k5q |> resize((sz.k5_n / 256l) * K5_QSB)
+            if (!stream_q) {
+                t.k5q |> reserve((sz.k5_n / 256l) * K5_QSB)
+                t.k5q |> resize((sz.k5_n / 256l) * K5_QSB)
+            }
             t.k5s |> reserve((sz.k5_n / 256l) * K5_SSB)
             t.k5s |> resize((sz.k5_n / 256l) * K5_SSB)
         }
         if (sz.k6_n > 0l) {
-            t.k6q |> reserve((sz.k6_n / 256l) * K6_QSB)
-            t.k6q |> resize((sz.k6_n / 256l) * K6_QSB)
+            if (!stream_q) {
+                t.k6q |> reserve((sz.k6_n / 256l) * K6_QSB)
+                t.k6q |> resize((sz.k6_n / 256l) * K6_QSB)
+            }
             t.k6s |> reserve((sz.k6_n / 256l) * K6_SSB)
             t.k6s |> resize((sz.k6_n / 256l) * K6_SSB)
         }
         if (sz.q40_n > 0l) {
-            t.q40q |> reserve((sz.q40_n / 256l) * Q40_QSB)
-            t.q40q |> resize((sz.q40_n / 256l) * Q40_QSB)
+            if (!stream_q) {
+                t.q40q |> reserve((sz.q40_n / 256l) * Q40_QSB)
+                t.q40q |> resize((sz.q40_n / 256l) * Q40_QSB)
+            }
             t.q40s |> reserve((sz.q40_n / 256l) * Q40_SSB)
             t.q40s |> resize((sz.q40_n / 256l) * Q40_SSB)
         }
         if (sz.q51_n > 0l) {
-            t.q51q |> reserve((sz.q51_n / 32l) * Q51_QB)
-            t.q51q |> resize((sz.q51_n / 32l) * Q51_QB)
+            if (!stream_q) {
+                t.q51q |> reserve((sz.q51_n / 32l) * Q51_QB)
+                t.q51q |> resize((sz.q51_n / 32l) * Q51_QB)
+            }
             t.q51s |> reserve((sz.q51_n / 32l) * Q51_SB)
             t.q51s |> resize((sz.q51_n / 32l) * Q51_SB)
         }
         if (mode == QuantMode.q8) {
-            t.qblob |> reserve(sz.wblob_n)
-            t.qblob |> resize(sz.wblob_n)
+            if (!stream_q) {
+                t.qblob |> reserve(sz.wblob_n)
+                t.qblob |> resize(sz.wblob_n)
+            }
             t.qscales |> reserve(sz.wblob_n / 32l)
             t.qscales |> resize(sz.wblob_n / 32l)
         } elif (mode == QuantMode.q4_0) {
@@ -4156,9 +4178,10 @@ def private load_gguf_parsed(var t : Model; m : GGUFMeta; bytes : array<uint8> |
         if (!t.config.shared_weights) {
             load_big(m, bytes, "output.weight", t, t.wcls_off, vocab * dim, scratch, 0l, t.wcls_fmt)
         } elif (t.cls_q8) {
-            // tied Q8: classifier copy (repacked below) + the linear copy embedding rows read
-            gguf_transcode_q8_0(m, bytes, "token_embd.weight", t.qblob, t.qscales, t.wcls_off, t.wcls_off / 32l, vocab * dim)
-            gguf_transcode_q8_0(m, bytes, "token_embd.weight", t.qblob, t.qscales, t.emb_q8_off, t.emb_q8_off / 32l, vocab * dim)
+            // tied Q8: classifier copy (repacked below) + the linear copy embedding rows read.
+            // Through load_big (its q8 arm is the same transcode) so the streaming plan records both.
+            load_big(m, bytes, "token_embd.weight", t, t.wcls_off, vocab * dim, scratch)
+            load_big(m, bytes, "token_embd.weight", t, t.emb_q8_off, vocab * dim, scratch)
         } elif (cls_kq(t)) {
             // tied K-quant: ONE plane copy serves the classifier matmul and embedding row reads
             // (the kq planes stay in disk order — no repack, so no second linear copy)

From eb19257988007537dbeb065796a83a10170f3cda Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 00:58:58 -0700
Subject: [PATCH 12/30] =?UTF-8?q?dlim=20arc=20phase=20D:=20the=20streaming?=
 =?UTF-8?q?=20fill=20executor=20=E2=80=94=20SHA-identical=20to=20eager,=20?=
 =?UTF-8?q?big=20planes=20never=20in=20RAM?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`dasllama-convert --stream` converts without materializing the big q-planes: the plan-mode
walk records FillJobs, load_gguf_streaming keeps the source mapping alive while
save_model_image_streaming's walk streams each jobbed field through fill_stream_plane — per
job: transcode into a job-sized temp (load_big's own arms at temp offset 0), scales land in
the RAM plane, the job's repack regions apply with the q pointer BIASED into the temp (the
repack walkers' collector halves feed the SAME regions — register_stream_layout in
dasllama_layout), and the temp appends to the direct writer. qblob's tail runs the wscale
epilogue — legal because every q-half precedes its scale-half in Model field order. Unstream-
able models (mx4/dn-grouped/bf16-ple/non-q8/shards) fail open to the eager path through the
same save call (empty jobs ≡ eager walk).

GATES PASSED — whole-file SHA identity vs eager conversion, x64-gen mr8 repack armed:
  Qwen3-4B Q4_K_M (kq transcode + grp8 repack + kq emb):  2323ebec…34e7 both
  Qwen3-4B Q8_0 (q8 + repack + tied-cls + wscale-f16):    96b97b33…af01 both
One real divergence found and fixed en route: the plan-mode wscale pre-mark set wscale_f16
unconditionally while the eager convert early-outs on EMPTY qscales (pure-kq models) — the
mark now mirrors the convert's outcome. Image mechanics+smol arms 9/9; lint+format clean.

Remaining for the phase receipts: GLM streamed peak-commit (busy-box-valid), then the judged
GLM wall-clock A/B on the cold box.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_common.das | 342 +++++++++++++++++-
 modules/dasLLAMA/dasllama/dasllama_image.das  | 135 +++++++
 modules/dasLLAMA/dasllama/dasllama_layout.das |  64 ++--
 utils/dasllama-convert/main.das               |  55 ++-
 4 files changed, 554 insertions(+), 42 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index ee772f34dc..50eebfcbfb 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -1679,9 +1679,244 @@ struct FillJob {
     fmt : KqFmt
 }
 
+//! One repack region over a plane (element offset + 2D shape). fmt ids follow the repack
+//! walkers: 0 = q8, 1 = mx4, 2 = q51, 4/5/6/40 = the kq plane pairs.
+struct StreamReg {
+    off : int64
+    n : int64
+    d : int64
+    fmt : int
+}
+
+typedef StreamCollectFn = function<(t : Model; var regs : array<StreamReg>) : void>
+typedef StreamRepackFn = function<(fmt : int; qp, sp : void?; n, d : int64) : void>
+
+[unused_argument(t, regs)]
+def private stream_no_collect(t : Model; var regs : array<StreamReg>) {
+    panic("dasLLAMA: no stream-layout hooks registered (dasllama_layout's [init] provides them)")
+}
+
+[unused_argument(fmt, qp, sp, n, d)]
+def private stream_no_repack(fmt : int; qp, sp : void?; n, d : int64) {
+    panic("dasLLAMA: no stream-repack hook registered (dasllama_layout's [init] provides it)")
+}
+
+var private g_stream_collect_q8 = @@stream_no_collect
+var private g_stream_collect_kq = @@stream_no_collect
+var private g_stream_collect_q51 = @@stream_no_collect
+var private g_stream_repack = @@stream_no_repack
+
+//! dasllama_layout registers the streaming-fill collaborators at [init]: the three region
+//! collectors (the repack walkers' build halves) and the single-region repack dispatcher.
+def register_stream_layout(cq8, ckq, cq51 : StreamCollectFn; rr : StreamRepackFn) {
+    g_stream_collect_q8 = cq8
+    g_stream_collect_kq = ckq
+    g_stream_collect_q51 = cq51
+    g_stream_repack = rr
+}
+
 var private g_fill_plan_mode = false
 var private g_fill_plan : array<FillJob>
 
+//! The regions the eager repack stage WOULD build for `t` — same gates, same walkers (the
+//! collector halves), so the streamed fill's per-job repack cannot drift from the eager one.
+def stream_collect_regions(t : Model; var regs : array<StreamReg>) {
+    if (t.quant != QuantMode.q8 || !select_matmul_backend_for_load()) {
+        return
+    }
+    invoke(g_stream_collect_q8, t, regs)
+    if (active_q51_layout_mr() > 1l) {
+        invoke(g_stream_collect_q51, t, regs)
+    }
+    if (t.kquant_native && kernel_backend_has_kq()) {
+        invoke(g_stream_collect_kq, t, regs)
+    }
+}
+
+// the streamed destination field of a job (Model plane field name), "" = not streamed
+def private stream_field_of(t : Model; fmt : KqFmt) : string {
+    if (fmt == KqFmt.k4) {
+        return "k4q"
+    } elif (fmt == KqFmt.k5) {
+        return "k5q"
+    } elif (fmt == KqFmt.k6) {
+        return "k6q"
+    } elif (fmt == KqFmt.q40) {
+        return "q40q"
+    } elif (fmt == KqFmt.q51) {
+        return "q51q"
+    } elif (t.quant == QuantMode.q8) {
+        return "qblob"
+    }
+    return ""
+}
+
+// (q plane bytes, scale plane bytes, region fmt id) for one streamed job
+[unused_argument(t)]
+def private stream_job_shape(t : Model; j : FillJob) : tuple<qb : int64; sb : int64; rfmt : int> {
+    if (j.fmt == KqFmt.k4) {
+        return (qb = (j.n / 256l) * K4_QSB, sb = (j.n / 256l) * K4_SSB, rfmt = 4)
+    } elif (j.fmt == KqFmt.k5) {
+        return (qb = (j.n / 256l) * K5_QSB, sb = (j.n / 256l) * K5_SSB, rfmt = 5)
+    } elif (j.fmt == KqFmt.k6) {
+        return (qb = (j.n / 256l) * K6_QSB, sb = (j.n / 256l) * K6_SSB, rfmt = 6)
+    } elif (j.fmt == KqFmt.q40) {
+        return (qb = (j.n / 256l) * Q40_QSB, sb = (j.n / 256l) * Q40_SSB, rfmt = 40)
+    } elif (j.fmt == KqFmt.q51) {
+        return (qb = (j.n / 32l) * Q51_QB, sb = (j.n / 32l) * Q51_SB, rfmt = 2)
+    }
+    return (qb = j.n, sb = 0l, rfmt = 0)   // q8: 1 byte/elem quants; scales handled as floats
+}
+
+//! Total bytes the streamed fill will append for `field` (page padding NOT included).
+def stream_plane_bytes(t : Model; jobs : array<FillJob>; field : string) : int64 {
+    var total = 0l
+    for (j in jobs) {
+        if (stream_field_of(t, j.fmt) == field) {
+            total += stream_job_shape(t, j).qb
+        }
+    }
+    return total
+}
+
+//! Execute every recorded job targeting `field`: transcode into a job-sized temp (load_big's
+//! own arms at temp offset 0), land scales in the RAM plane, apply the job's repack regions
+//! (temp-biased q, in-place s), hand the temp to `append`; qblob's tail runs the wscale epilogue.
+def fill_stream_plane(m : GGUFMeta; bytes : array<uint8> | #; var t : Model; field : string;
+                      jobs : array<FillJob>; regs : array<StreamReg>;
+                      append : block<(p : void?; nbytes : uint64) : void>) : bool {
+    // jobs for this field, ascending woff — plane order IS ascending source order
+    var mine : array<FillJob>
+    for (j in jobs) {
+        if (stream_field_of(t, j.fmt) == field) {
+            mine |> push(j)
+        }
+    }
+    if (empty(mine)) {
+        return true
+    }
+    mine |> sort() $(a, b : FillJob) => a.woff < b.woff
+    var temp_q : array<uint8>
+    var temp_q8 : array<int8>   // the q8 family's quant temp (qblob is int8)
+    var temp_s : array<uint8>
+    var temp_sf : array<float>
+    var scratch : array<float>
+    for (j in mine) {
+        let sh = stream_job_shape(t, j)
+        temp_q |> resize(int(sh.qb))
+        let t0 = g_conv_prof ? ref_time_ticks() : 0l
+        var kind = "q8 transcode (Q8_0 verbatim)"
+        if (j.fmt == KqFmt.k4) {
+            temp_s |> resize(int(sh.sb))
+            gguf_transcode_q4k(m, bytes, j.name, temp_q, temp_s, 0l, j.n, j.src_off)
+            kind = "k4 transcode (Q4_K)"
+        } elif (j.fmt == KqFmt.k5) {
+            temp_s |> resize(int(sh.sb))
+            if (gguf_tensor_type(m, j.name) == GGML_TYPE_Q5_K) {
+                gguf_transcode_q5k(m, bytes, j.name, temp_q, temp_s, 0l, j.n, j.src_off)
+                kind = "k5 transcode (Q5_K)"
+            } else {
+                scratch |> resize(int(j.n))
+                gguf_read_tensor_f32(m, bytes, j.name, scratch, 0l, j.n, j.src_off)
+                quantize_k5_plane(scratch, j.n, temp_q, temp_s, 0l)
+                kind = "k5 RE-ENCODE (Q5_0 dequant+quant)"
+            }
+        } elif (j.fmt == KqFmt.k6) {
+            temp_s |> resize(int(sh.sb))
+            gguf_transcode_q6k(m, bytes, j.name, temp_q, temp_s, 0l, j.n, j.src_off)
+            kind = "k6 transcode (Q6_K)"
+        } elif (j.fmt == KqFmt.q40) {
+            temp_s |> resize(int(sh.sb))
+            gguf_transcode_q40(m, bytes, j.name, temp_q, temp_s, 0l, j.n, j.src_off)
+            kind = "q40 transcode (Q4_0)"
+        } elif (j.fmt == KqFmt.q51) {
+            temp_s |> resize(int(sh.sb))
+            gguf_transcode_q51(m, bytes, j.name, temp_q, temp_s, 0l, j.n, j.src_off)
+            kind = "q51 transcode (Q5_1)"
+        } else {
+            // q8 family: scales are FLOATS; the epilogue converts the whole plane at the end
+            temp_q8 |> resize(int(j.n))
+            temp_sf |> resize(int(j.n / 32l))
+            let gt = gguf_tensor_type(m, j.name)
+            if (gt == GGML_TYPE_Q8_0) {
+                gguf_transcode_q8_0(m, bytes, j.name, temp_q8, temp_sf, 0l, 0l, j.n, j.src_off)
+            } elif (gt == GGML_TYPE_Q5_0) {
+                gguf_transcode_q5_0_to_q8(m, bytes, j.name, temp_q8, temp_sf, 0l, 0l, j.n, j.src_off)
+                kind = "q8 transcode (Q5_0 exact)"
+            } else {
+                scratch |> resize(int(j.n))
+                gguf_read_tensor_f32(m, bytes, j.name, scratch, 0l, j.n, j.src_off)
+                quantize_q8_0_into(scratch, j.n, temp_q8, temp_sf, 0l, 0l)
+                kind = "q8 REQUANT (dequant+quant)"
+            }
+        }
+        conv_note(kind, t0, j.n)
+        // land the scale half at its real offset (RAM-resident plane)
+        unsafe {
+            if (j.fmt == KqFmt.k4) {
+                memcpy(addr<void?>(t.k4s[(j.woff / 256l) * K4_SSB]), addr<void?>(temp_s[0]), sh.sb)
+            } elif (j.fmt == KqFmt.k5) {
+                memcpy(addr<void?>(t.k5s[(j.woff / 256l) * K5_SSB]), addr<void?>(temp_s[0]), sh.sb)
+            } elif (j.fmt == KqFmt.k6) {
+                memcpy(addr<void?>(t.k6s[(j.woff / 256l) * K6_SSB]), addr<void?>(temp_s[0]), sh.sb)
+            } elif (j.fmt == KqFmt.q40) {
+                memcpy(addr<void?>(t.q40s[(j.woff / 256l) * Q40_SSB]), addr<void?>(temp_s[0]), sh.sb)
+            } elif (j.fmt == KqFmt.q51) {
+                memcpy(addr<void?>(t.q51s[(j.woff / 32l) * Q51_SB]), addr<void?>(temp_s[0]), sh.sb)
+            } elif (sh.sb == 0l && j.n > 0l) {
+                memcpy(addr<void?>(t.qscales[j.woff / 32l]), addr<void?>(temp_sf[0]), (j.n / 32l) * 4l)
+            }
+        }
+        // per-job repack: this job's regions applied on the temp (q half, pointer biased to
+        // woff 0) and the real scale plane (in place) — the same backend fns, same regions
+        unsafe {
+            for (r in regs) {
+                if (r.fmt != sh.rfmt || r.off < j.woff || r.off >= j.woff + j.n) {
+                    continue
+                }
+                if (r.fmt == 0) {
+                    invoke(g_stream_repack, 0, addr<void?>(temp_q8[r.off - j.woff]),
+                        addr<void?>(t.qscales[r.off / 32l]), r.n, r.d)
+                } elif (r.fmt == 2) {
+                    invoke(g_stream_repack, 2, addr<void?>(temp_q[((r.off - j.woff) / 32l) * Q51_QPB]),
+                        addr<void?>(t.q51s[(r.off / 32l) * Q51_SPB]), r.n, r.d)
+                } elif (r.fmt == 4) {
+                    invoke(g_stream_repack, 4, addr<void?>(temp_q[((r.off - j.woff) / 256l) * K4_QSB]),
+                        addr<void?>(t.k4s[(r.off / 256l) * K4_SSB]), r.n, r.d)
+                } elif (r.fmt == 5) {
+                    invoke(g_stream_repack, 5, addr<void?>(temp_q[((r.off - j.woff) / 256l) * K5_QSB]),
+                        addr<void?>(t.k5s[(r.off / 256l) * K5_SSB]), r.n, r.d)
+                } elif (r.fmt == 6) {
+                    invoke(g_stream_repack, 6, addr<void?>(temp_q[((r.off - j.woff) / 256l) * K6_QSB]),
+                        addr<void?>(t.k6s[(r.off / 256l) * K6_SSB]), r.n, r.d)
+                } elif (r.fmt == 40) {
+                    invoke(g_stream_repack, 40, addr<void?>(temp_q[((r.off - j.woff) / 256l) * Q40_QSB]),
+                        addr<void?>(t.q40s[(r.off / 256l) * Q40_SSB]), r.n, r.d)
+                }
+            }
+        }
+        unsafe {
+            if (sh.rfmt == 0) {
+                invoke(append, addr<void?>(temp_q8[0]), uint64(sh.qb))
+            } else {
+                invoke(append, addr<void?>(temp_q[0]), uint64(sh.qb))
+            }
+        }
+    }
+    if (field == "qblob" && g_wscale_f16) {
+        // the epilogue: scales are complete and repacked; qscales16 lands BEFORE its field
+        // writes (qblob precedes qscales/qscales16 in Model field order)
+        wscale_convert_f16(t)
+    }
+    delete mine
+    delete temp_q
+    delete temp_q8
+    delete temp_s
+    delete temp_sf
+    delete scratch
+    return true
+}
+
 //! Arm plan recording: subsequent load_big calls append FillJobs instead of transcoding
 //! (smalls still load eagerly — fblob is small and every flavor keeps it).
 def fill_plan_begin {
@@ -3328,6 +3563,57 @@ def load_gguf(path : string; mode : QuantMode = QuantMode.fp32) : Model {
     return <- t
 }
 
+//! Streaming-conversion entry: plan-load `t`, then invoke `blk(m, bytes)` with the source
+//! mapping STILL ALIVE — the caller streams the save inside. Fails open (unstreamable models
+//! materialize + save eagerly through the same blk); split shards return false pre-blk.
+def load_gguf_streaming(path : string; mode : QuantMode; var t : Model; var jobs : array<FillJob>;
+                        blk : block<(m : GGUFMeta; bytes : array<uint8> const#) : bool>) : bool {
+    var shards <- gguf_shard_paths(path)
+    let nshards = length(shards)
+    delete shards
+    if (nshards > 1) {
+        return false
+    }
+    if (!is_job_que_available()) {
+        var okj = false
+        with_job_que() {
+            okj = load_gguf_streaming(path, mode, t, jobs, blk)
+        }
+        return okj
+    }
+    g_weights_epoch++
+    t.quant = mode
+    if (has_env_variable("DASLLAMA_CONV_PROF")) {
+        set_conv_profile(true)
+    }
+    let ts_load = ref_time_ticks()
+    let f = fopen(path, "rb")
+    if (f == null) {
+        return false
+    }
+    var ok = false   // nolint:LINT003 — written inside the fmap block
+    let lmode = mode
+    fmap(f) $(var bytes : array<uint8>#) {
+        if (env_flag("DASLLAMA_PREFETCH", true)) {
+            var armed = false
+            unsafe {
+                armed = prefetch_map(addr<void?>(bytes[0]), uint64(long_length(bytes)))
+            }
+            if (armed) {
+                to_log(LOG_INFO, "dasLLAMA: source prefetch armed ({long_length(bytes) >> 20l} MB)\n")
+            }
+        }
+        var inscope m <- parse_gguf_meta(bytes)
+        fill_plan_begin()
+        load_gguf_parsed(t, m, bytes, lmode, ts_load)
+        fill_plan_take(jobs)
+        t.tok <- load_tokenizer_auto(path)
+        ok = invoke(blk, m, bytes)
+    }
+    fclose(f)
+    return ok
+}
+
 def private load_gguf_impl(path : string; var mode : QuantMode) : Model {
     g_weights_epoch++
     var t = Model()
@@ -4212,31 +4498,53 @@ def private load_gguf_parsed(var t : Model; m : GGUFMeta; bytes : array<uint8> |
         // arm64: switch to the laneq backend and repack the just-loaded Q8 weights into its interleaved
         // layout. Returns false off-ARM (portable stays, weights stay row-major).
         if (mode == QuantMode.q8 && select_matmul_backend_for_load()) {
-            repack_q8_weights(t)
-            if (t.experts_mx4) {
-                repack_mx4_stacks(t)
-            }
-            if (active_q51_layout_mr() > 1l) {
-                repack_q51_stacks(t)
-            }
-            if (t.kquant_native && kernel_backend_has_kq()) {
-                repack_kq_weights(t)
-                t.kq_repacked = true
-                t.kq_repack_mr4 = active_kq_layout_mr(4)
-                t.kq_repack_mr5 = active_kq_layout_mr(5)
-                t.kq_repack_mr6 = active_kq_layout_mr(6)
-                t.kq_repack_mr40 = active_kq_layout_mr(40)
-                to_log(LOG_INFO, "dasLLAMA: K-quant planes repacked to the '{active_kernel_backend()}' layouts (k4 grp{t.kq_repack_mr4}, k5 grp{t.kq_repack_mr5}, k6 grp{t.kq_repack_mr6}, q40 grp{t.kq_repack_mr40})\n")
+            if (g_fill_plan_mode) {
+                // streaming: the q-halves are not materialized — the fill applies the SAME
+                // regions per job. Set the marks the eager walkers would (the meta serializes
+                // BEFORE the streamed planes fill), run nothing.
+                t.mx4_repacked = true
+                if (t.kquant_native && kernel_backend_has_kq()) {
+                    t.kq_repacked = true
+                    t.kq_repack_mr4 = active_kq_layout_mr(4)
+                    t.kq_repack_mr5 = active_kq_layout_mr(5)
+                    t.kq_repack_mr6 = active_kq_layout_mr(6)
+                    t.kq_repack_mr40 = active_kq_layout_mr(40)
+                }
+            } else {
+                repack_q8_weights(t)
+                if (t.experts_mx4) {
+                    repack_mx4_stacks(t)
+                }
+                if (active_q51_layout_mr() > 1l) {
+                    repack_q51_stacks(t)
+                }
+                if (t.kquant_native && kernel_backend_has_kq()) {
+                    repack_kq_weights(t)
+                    t.kq_repacked = true
+                    t.kq_repack_mr4 = active_kq_layout_mr(4)
+                    t.kq_repack_mr5 = active_kq_layout_mr(5)
+                    t.kq_repack_mr6 = active_kq_layout_mr(6)
+                    t.kq_repack_mr40 = active_kq_layout_mr(40)
+                    to_log(LOG_INFO, "dasLLAMA: K-quant planes repacked to the '{active_kernel_backend()}' layouts (k4 grp{t.kq_repack_mr4}, k5 grp{t.kq_repack_mr5}, k6 grp{t.kq_repack_mr6}, q40 grp{t.kq_repack_mr40})\n")
+                }
             }
         }
         to_log(LOG_INFO, "dasLLAMA: load stage repack: {get_time_usec(ts_stage) / 1000} ms\n")
         ts_stage = ref_time_ticks()
         if (mode == QuantMode.q8 && g_wscale_f16) {
-            wscale_convert_f16(t)
+            if (g_fill_plan_mode) {
+                // streaming: the epilogue converts after qblob fills; pre-mark for the meta,
+                // mirroring the convert's own outcome (empty scales = nothing converts, no flag)
+                t.wscale_f16 = !empty(t.qscales) && kernel_backend_has_wscale16()
+            } else {
+                wscale_convert_f16(t)
+            }
         }
         to_log(LOG_INFO, "dasLLAMA: load stage wscale: {get_time_usec(ts_stage) / 1000} ms, total {get_time_usec(ts_load) / 1000} ms\n")
         log_load_report(t)
-        moe_gpu_upload_resident(t)
+        if (!g_fill_plan_mode) {   // streaming converts only — no serving, no gathers over unmade planes
+            moe_gpu_upload_resident(t)
+        }
     }
 }
 
diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index fa492a0407..15c0997b77 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -568,6 +568,141 @@ def save_model_image(var t : Model; path : string; tag : string = ""; quant : st
     return save_image(t, path, tag, quant)
 }
 
+//! save_image's STREAMING twin (Model-only): fields with recorded FillJobs stream through
+//! fill_stream_plane; empty `jobs` degrades to the eager save exactly. Call from
+//! load_gguf_streaming's block (m/bytes must be alive); keep the tails in step with save_image.
+def save_model_image_streaming(var t : Model; m : GGUFMeta; bytes : array<uint8> | #;
+                               var jobs : array<FillJob>; path : string; tag : string = ""; quant : string = "q8") : bool {
+    let tmp_path = "{path}.{ref_time_ticks()}.tmp"
+    let dcfg = dlim_config_current(quant)
+    let ident = dlim_identity(dcfg, IMAGE_VERSION, tag)
+    var fend = 0ul
+    var meta_off = 0ul
+    var meta_bytes = 0ul
+    var nsections = 0
+    var meta <- new MemSerializer()
+    var warch = Archive(reading = false, stream = meta)
+    var sections : array<ImgSection>
+    let ts_meta = ref_time_ticks()
+    serialize_image_meta(warch, t)
+    to_log(LOG_INFO, "dasLLAMA image: meta serialize {get_time_usec(ts_meta) / 1000}ms\n")
+    var scalar_blob <- meta->extractData()
+    unsafe {
+        delete meta
+    }
+    // preallocation: the generic total (streamed fields are empty, contributing 0) plus each
+    // streamed plane's exact bytes + a page of padding, plus the pending-wscale qscales16
+    // (absent until the epilogue). Over-reserve is free — dwrite_close truncates.
+    var extra = 0ul
+    for (fname in ["qblob", "k4q", "k5q", "k6q", "q40q", "q51q"]) {
+        let sb = stream_plane_bytes(t, jobs, fname)
+        if (sb > 0l) {
+            extra += uint64(sb) + uint64(IMAGE_PAGE)
+        }
+    }
+    if (t.wscale_f16 && empty(t.qscales16) && !empty(t.qscales)) {
+        extra += uint64(long_length(t.qscales) * 2l) + uint64(IMAGE_PAGE)
+    }
+    var regs : array<StreamReg>
+    stream_collect_regions(t, regs)
+    var fill_ok = true
+    var w = w_open(tmp_path, image_total_bytes(t, uint64(long_length(scalar_blob)) + SECTION_TABLE_SLACK) + extra)
+    if (w.ok) {
+        w_zeros(w, uint64(IMAGE_PAGE))   // page 0: header placeholder — patched after close
+        let ts_planes = ref_time_ticks()
+        apply(t) $(name : string; var field) {
+            static_if (typeinfo is_array(field)) {
+                static_if (!typeinfo is_string(field[0])) {
+                    if (stream_plane_bytes(t, jobs, name) > 0l) {
+                        let padded = pad_to_page(w.cur)
+                        w_zeros(w, padded - w.cur)
+                        let at = w.cur
+                        if (!fill_stream_plane(m, bytes, t, name, jobs, regs) $(p : void?; nb : uint64) { w_append(w, p, nb) }) {
+                            fill_ok = false
+                        }
+                        sections |> push(ImgSection(name = name, off = at, bytes = w.cur - at))
+                    } else {
+                        write_plane(w, sections, name, field)
+                    }
+                }
+            }
+        }
+        let planes_ms = int64(get_time_usec(ts_planes)) / 1000l
+        let planes_mb = int64(w.cur) >> 20l
+        to_log(LOG_INFO, "dasLLAMA image: streamed planes write {planes_ms}ms ({planes_mb} MB at {planes_ms > 0l ? planes_mb * 1000l / planes_ms : 0l} MB/s)\n")
+        var smeta <- new MemSerializer()
+        var sarch = Archive(reading = false, stream = smeta)
+        var m_ident = ident
+        var m_cfg = dlim_config_json(dcfg)
+        sarch |> serialize(m_ident)
+        sarch |> serialize(m_cfg)
+        sarch |> serialize(sections)
+        var meta_blob <- smeta->extractData()
+        meta_blob |> push_from(scalar_blob)
+        nsections = length(sections)
+        meta_off = w.cur
+        meta_bytes = uint64(long_length(meta_blob))
+        if (meta_bytes > 0ul) {
+            unsafe {
+                w_append(w, addr<void?>(meta_blob[0]), meta_bytes)
+            }
+        }
+        fend = pad_to_page(w.cur)
+        w_zeros(w, fend - w.cur)
+        delete meta_blob
+        unsafe {
+            delete smeta
+        }
+        delete sections
+    }
+    delete scalar_blob
+    delete regs
+    var ok = w_close(w) && fill_ok
+    if (ok) {
+        var hdr : array<uint8>
+        hdr |> resize(int(IMAGE_HEADER_BYTES))
+        store_u32(hdr, 0, IMAGE_MAGIC)
+        store_u32(hdr, 4, uint(IMAGE_VERSION))
+        store_u32(hdr, 8, uint(IMAGE_PAGE))
+        store_u32(hdr, 12, uint(nsections))
+        store_u64(hdr, 16, meta_off)
+        store_u64(hdr, 24, meta_bytes)
+        store_u64(hdr, 32, fend)
+        store_u64(hdr, 40, hash(ident))
+        ok = false
+        fopen(tmp_path, "r+b") $(hf) {
+            if (hf != null) {
+                fseek(hf, 0l, seek_set)
+                ok = int64(hf |> fwrite(hdr)) == IMAGE_HEADER_BYTES
+            }
+        }
+        if (!ok) {
+            to_log(LOG_ERROR, "dasLLAMA image: '{tmp_path}' header patch failed — image save aborted\n")
+        }
+        delete hdr
+    }
+    if (ok) {
+        var st : FStat
+        if (!stat(tmp_path, st) || st.size != fend) {
+            to_log(LOG_ERROR, "dasLLAMA image: '{tmp_path}' is {int64(st.size)} bytes on disk, expected {int64(fend)} — disk full? image save aborted\n")
+            ok = false
+        }
+    }
+    if (!ok) {
+        if (stat(tmp_path).is_valid && !remove(tmp_path)) {
+            to_log(LOG_WARNING, "dasLLAMA image: orphaned tmp '{tmp_path}' could not be removed — clean it up by hand\n")
+        }
+        return false
+    }
+    // POSIX rename-over is atomic; Windows needs remove-then-rename (a concurrent reader may
+    // regenerate in the window)
+    if (rename(tmp_path, path) || (remove(path) && rename(tmp_path, path))) {
+        return true
+    }
+    to_log(LOG_ERROR, "dasLLAMA image: could not move '{tmp_path}' over '{path}'\n")
+    return false
+}
+
 // ===== load =====
 
 // one plane: validate the section against the mapping, then borrow it in place
diff --git a/modules/dasLLAMA/dasllama/dasllama_layout.das b/modules/dasLLAMA/dasllama/dasllama_layout.das
index e968f01a5a..e78439de1c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_layout.das
+++ b/modules/dasLLAMA/dasllama/dasllama_layout.das
@@ -196,28 +196,21 @@ def private compact_kq_scale_strip(var ks : array<uint8>) {
 
 // ===== CPU repack walkers (backend grp<mr> interleave, in place at load) =====
 
-// A repack work item: one mr-aligned row-chunk of a weight region. fmt: 0 = q8 (qblob/qscales),
-// 1 = mx4 (mxq/mxs), 4/5/6 = the kq plane pairs. Chunking splits huge regions (the classifier) for
-// load balance; 1024 is a multiple of every backend mr, so row groups never straddle a boundary.
-struct private RepackReg {
-    off : int64
-    n : int64
-    d : int64
-    fmt : int
-}
-
-def private push_repack(var regs : array<RepackReg>; fmt : int; off, n, d : int64) {
+// A repack work item is common's StreamReg (fmt: 0 = q8, 1 = mx4, 2 = q51, 4/5/6/40 = kq).
+// Chunking splits huge regions (the classifier) for load balance; 1024 is a multiple of every
+// backend mr, so row groups never straddle a boundary.
+def private push_repack(var regs : array<StreamReg>; fmt : int; off, n, d : int64) {
     var r0 = 0l
     while (r0 < d) {
         let rc = min(1024l, d - r0)
-        regs |> push(RepackReg(off = off + r0 * n, n = n, d = rc, fmt = fmt))
+        regs |> push(StreamReg(off = off + r0 * n, n = n, d = rc, fmt = fmt))
         r0 += rc
     }
 }
 
 // Run every collected repack across the jobque — regions are disjoint, so any lane count is
 // bit-exact. Workers touch hoisted raw pointers + the hoisted backend fn values only.
-def private repack_regions(var t : Model; regs : array<RepackReg>) {
+def private repack_regions(var t : Model; regs : array<StreamReg>) {
     if (empty(regs)) {
         return
     }
@@ -254,7 +247,7 @@ def private repack_regions(var t : Model; regs : array<RepackReg>) {
         if (!empty(t.q40s)) { q40sp = addr(t.q40s[0]) }
         if (!empty(t.q51q)) { q51qp = addr(t.q51q[0]) }
         if (!empty(t.q51s)) { q51sp = addr(t.q51s[0]) }
-        let rp = addr<RepackReg const?>(regs[0])
+        let rp = addr<StreamReg const?>(regs[0])
         let nr = length(regs)
         let njobs = is_job_que_available() ? min(nr, 4 * (get_total_hw_jobs() + 1)) : 1
         maybe_parallel_for(0, nr, njobs) $(rb, re) {
@@ -284,11 +277,10 @@ def private repack_regions(var t : Model; regs : array<RepackReg>) {
 // Repack every Q8 2D weight tensor in qblob/qscales into the active backend's interleaved layout,
 // IN PLACE, once at load. Mirrors forward()'s per-tensor offsets/shapes exactly; the embedding +
 // norms live in fblob and are never touched.
-def private repack_q8_weights(var t : Model) {
+def private collect_q8_regions(t : Model; var regs : array<StreamReg>) {
     let c = t.config
     let dim = c.dim
     let hidden = c.hidden_dim
-    var regs : array<RepackReg>
     for (l in range64(c.n_layers + c.n_layer_nextn)) {   // + the MTP/NextN block at index n_layers
         let kv = layer_kv_dim(c, l)
         let qd = layer_qd(c, l)
@@ -379,13 +371,18 @@ def private repack_q8_weights(var t : Model) {
     if (c.n_layer_nextn > 0l && t.mtp_ehproj_fmt == KqFmt.q8) {   // NextN eh_proj: 2*dim -> dim
         push_repack(regs, 0, t.mtp_ehproj_off, 2l * dim, dim)
     }
+}
+
+def private repack_q8_weights(var t : Model) {
+    var regs : array<StreamReg>
+    collect_q8_regions(t, regs)
     repack_regions(t, regs)
     t.mx4_repacked = true
     delete regs
 }
 
 // route one kq-tagged tensor to its format's plane pair (q8 tags no-op — those live in qblob)
-def private push_repack_kq(var regs : array<RepackReg>; fmt : KqFmt; woff, n, d : int64) {
+def private push_repack_kq(var regs : array<StreamReg>; fmt : KqFmt; woff, n, d : int64) {
     if (fmt == KqFmt.k4) {
         push_repack(regs, 4, woff, n, d)
     } elif (fmt == KqFmt.k5) {
@@ -400,10 +397,9 @@ def private push_repack_kq(var regs : array<RepackReg>; fmt : KqFmt; woff, n, d
 // Repack every K-quant-tagged weight tensor into the active backend's grp<mr> kq layout, IN
 // PLACE — the kq sibling of repack_q8_weights, called only when the backend carries kq slots.
 // The tied/untied classifier repacks too: embed_row gathers its rows through the grp layout after.
-def private repack_kq_weights(var t : Model) {
+def private collect_kq_regions(t : Model; var regs : array<StreamReg>) {
     let c = t.config
     let dim = c.dim
-    var regs : array<RepackReg>
     for (l in range64(c.n_layers + c.n_layer_nextn)) {   // + the MTP/NextN block at index n_layers
         let kv = layer_kv_dim(c, l)
         let qd = layer_qd(c, l)
@@ -454,6 +450,11 @@ def private repack_kq_weights(var t : Model) {
     if (c.n_layer_nextn > 0l) {   // NextN eh_proj (no-op for q8 tags)
         push_repack_kq(regs, t.mtp_ehproj_fmt, t.mtp_ehproj_off, 2l * dim, dim)
     }
+}
+
+def private repack_kq_weights(var t : Model) {
+    var regs : array<StreamReg>
+    collect_kq_regions(t, regs)
     repack_regions(t, regs)
     delete regs
 }
@@ -465,7 +466,7 @@ def private repack_mx4_stacks(var t : Model) {
     let c = t.config
     let dim = c.dim
     let ege = dim * c.n_ff_exp
-    var regs : array<RepackReg>
+    var regs : array<StreamReg>
     for (l in range64(c.n_layers)) {
         for (e in range64(c.n_expert)) {
             let base = e * ege
@@ -480,11 +481,10 @@ def private repack_mx4_stacks(var t : Model) {
 
 // q51-native expert stacks -> the active backend's grp<mr> q51 layout (per-stack: a model can
 // mix q51 downs with k4 gates, e.g. gemma-4-26B-A4B). No-op unless a stack is tagged q51.
-def private repack_q51_stacks(var t : Model) {
+def private collect_q51_regions(t : Model; var regs : array<StreamReg>) {
     let c = t.config
     let dim = c.dim
     let ege = dim * c.n_ff_exp
-    var regs : array<RepackReg>
     for (l in range64(c.n_layers)) {
         let f1q = fmt_at(t.we1_fmt, l) == KqFmt.q51
         let f2q = fmt_at(t.we2_fmt, l) == KqFmt.q51
@@ -505,6 +505,11 @@ def private repack_q51_stacks(var t : Model) {
             }
         }
     }
+}
+
+def private repack_q51_stacks(var t : Model) {
+    var regs : array<StreamReg>
+    collect_q51_regions(t, regs)
     if (!empty(regs)) {
         repack_regions(t, regs)
         to_log(LOG_INFO, "dasLLAMA: q51 expert planes repacked to grp{active_q51_layout_mr()}\n")
@@ -512,6 +517,20 @@ def private repack_q51_stacks(var t : Model) {
     delete regs
 }
 
+// StreamRepackFn: one region through the active backend's repack, on caller-supplied pointers
+// (the streamed fill biases the q pointer into its temp; scales stay in the RAM plane)
+def private stream_repack_one(fmt : int; qp, sp : void?; n, d : int64) {
+    unsafe {
+        if (fmt == 0) {
+            invoke(g_repack_q8q8, reinterpret<int8?>(qp), reinterpret<float?>(sp), n, d)
+        } elif (fmt == 2) {
+            invoke(g_repack_q51, reinterpret<uint8?>(qp), reinterpret<uint8?>(sp), n, d)
+        } else {
+            invoke(g_repack_kq, fmt, reinterpret<uint8?>(qp), reinterpret<uint8?>(sp), n, d)
+        }
+    }
+}
+
 // ===== GPU tier gathers (prepared planes -> device-layout bytes) =====
 
 // Gather one PREPARED Q8 weight stack into the GPU tier's two row-major planes — int8 quants +
@@ -817,4 +836,5 @@ def moe_gpu_gather_stack_kq(t : Model; fmt : KqFmt; woff : int64; n, rows, slice
 def private register_layout_hooks {
     register_model_layout(@@repack_q8_weights, @@repack_kq_weights, @@repack_mx4_stacks, @@repack_q51_stacks,
         @@moe_gpu_gather_stack, @@moe_gpu_gather_stack_kq, @@moe_gpu_gather_stack_q8n)
+    register_stream_layout(@@collect_q8_regions, @@collect_kq_regions, @@collect_q51_regions, @@stream_repack_one)
 }
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 3cde0c89ef..4c3d148fe4 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -25,6 +25,7 @@ require dasllama/dasllama_math          // apply_box_profile_runtime + select_ma
 require dasllama/dasllama_image         // the .dlim rail itself
 require dasllama/dasllama_layout        // convert_model_to_metal_blob — the metal flavor's transform
 require dasllama/dasllama_config        // DlimConfiguration — --config / --dump-config
+require dasllama/dasllama_gguf          // GGUFMeta — the streaming block's mapping handle
 require daslib/clargs
 require daslib/jobque_boost
 require daslib/fio
@@ -67,6 +68,9 @@ struct ConvertArgs {
     @clarg_doc = "P3 trim (with -f vulkan): drop the big CPU weight families from the image — pure resident-driver dense models only; serve with DASLLAMA_TRIM=1"
     trim : bool
 
+    @clarg_doc = "Streaming conversion (planar q8): big planes go source->transcode->image without materializing in RAM; unstreamable models fall back to eager automatically"
+    stream : bool
+
     @clarg_doc = "Convert even if a valid image is already there (default: report it and exit 0)"
     force : bool
 
@@ -270,13 +274,59 @@ def main() : int {
         return 0
     }
 
+    if (cfg.stream && cfg.flavor != Flavor.planar) {
+        to_log(LOG_ERROR, "dasllama-convert: --stream covers the planar flavor (metal/vulkan bakes convert eagerly)\n")
+        return 2
+    }
     var rc = 0
+    var did_stream = false
     let ts = ref_time_ticks()
     // the job que carries the transcode/repack passes; the load spins its own if we do not
     with_job_que() {
-        if (cfg.flavor == Flavor.vulkan) {
-            vulkan_bake_begin()   // the load's GPU walk collects into the bake blob (dry — no uploads)
+        if (cfg.stream && cfg.flavor == Flavor.planar) {
+            apply_box_profile_runtime()
+            var mt = Model()
+            var jobs : array<FillJob>
+            var blk_ran = false
+            let sok = load_gguf_streaming(cfg.model, qm, mt, jobs) $(gm : GGUFMeta; gbytes : array<uint8> const#) {
+                blk_ran = true
+                if (empty(jobs)) {
+                    to_log(LOG_INFO, "dasllama-convert: streaming unavailable for this model — writing eagerly from RAM\n")
+                }
+                return save_model_image_streaming(mt, gm, gbytes, jobs, out, tag, qs)
+            }
+            if (sok || blk_ran) {
+                did_stream = true
+                rc = sok ? 0 : 1
+                if (rc != 0) {
+                    to_log(LOG_ERROR, "dasllama-convert: streamed write of '{out}' failed — see the error above\n")
+                }
+            } else {
+                to_log(LOG_INFO, "dasllama-convert: streaming declined (split shards?) — converting eagerly\n")
+            }
+            delete jobs
+            delete mt
+        }
+        if (!did_stream) {
+            if (cfg.flavor == Flavor.vulkan) {
+                vulkan_bake_begin()   // the load's GPU walk collects into the bake blob (dry — no uploads)
+            }
+            stream_eager_convert(cfg, qm, qs, out, tag, rc)
         }
+    }
+    if (rc == 0 && did_stream) {
+        var st : FStat
+        let bytes = stat(out, st) ? int64(st.size) : 0l
+        let total_ms = int64(get_time_usec(ts)) / 1000l
+        to_log(LOG_INFO, "dasllama-convert: wrote {bytes >> 20l} MB (streamed) in {total_ms} ms total\n")
+    }
+    return rc
+}
+
+// the pre-streaming eager conversion body, verbatim (load whole -> flavor transform -> save)
+def private stream_eager_convert(cfg : ConvertArgs; qm : QuantMode; qs, out, tag : string; var rc : int&) {
+    let ts = ref_time_ticks()
+    {
         var m <- load_model_(cfg.model, qm)
         let ts_load = ref_time_ticks()
         if (cfg.flavor == Flavor.metal) {
@@ -307,5 +357,4 @@ def main() : int {
         }
         delete m
     }
-    return rc
 }

From 08a84a4b9e30d640d44f40b266f5725d05d3cf7a Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 01:19:09 -0700
Subject: [PATCH 13/30] =?UTF-8?q?dlim=20arc=20phase=20D:=20split-shard=20s?=
 =?UTF-8?q?treaming=20+=20THE=20MEMORY=20RECEIPT=20=E2=80=94=20GLM=20peak?=
 =?UTF-8?q?=2081.9=20->=2016.34=20GB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

load_gguf_streaming grows the split-gguf arm (every shard mapping alive across plan-load AND
the blk-save; per-shard prefetch; the transcode kernels resolve shard bases through the meta),
and the blk signature settles on a plain array view served by temp_array in both arms.

THE PHASE'S RECEIPT (busy-box-valid — it is a memory number, not a timing): converting the
73 GB split GLM-4.5-Air Q4_K_M with --stream peaked at 16.34 GB private (sampled at 500 ms)
vs the banked 81.9 GB eager peak — 5x less, the model never in RAM. The wscale epilogue ran
on the real mixed q8+kq model (1.09 B scales converted mid-save); the produced image maps and
parses cleanly (NextN offsets, mr8 marks, flags all sane). Q4_K_M re-gated SHA-identical
after the signature change (2323ebec…).

Honest wall-clock note: streamed GLM took 640 s on a busy box vs eager's ~145 s — the serial
transcode-then-append per job leaves the device idle during transcode and vice versa. The
async-writer overlap (double-buffered temps) is the known next slice; its judged GLM A/B is
the cold-box measurement this arc parks on.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WQW3fFpEpq8YtqNZTVh7jJ
---
 modules/dasLLAMA/dasllama/dasllama_common.das | 52 ++++++++++++++++---
 utils/dasllama-convert/main.das               |  2 +-
 2 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index 50eebfcbfb..9f7e1aa1b6 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -3567,13 +3567,7 @@ def load_gguf(path : string; mode : QuantMode = QuantMode.fp32) : Model {
 //! mapping STILL ALIVE — the caller streams the save inside. Fails open (unstreamable models
 //! materialize + save eagerly through the same blk); split shards return false pre-blk.
 def load_gguf_streaming(path : string; mode : QuantMode; var t : Model; var jobs : array<FillJob>;
-                        blk : block<(m : GGUFMeta; bytes : array<uint8> const#) : bool>) : bool {
-    var shards <- gguf_shard_paths(path)
-    let nshards = length(shards)
-    delete shards
-    if (nshards > 1) {
-        return false
-    }
+                        blk : block<(m : GGUFMeta; bytes : array<uint8>) : bool>) : bool {
     if (!is_job_que_available()) {
         var okj = false
         with_job_que() {
@@ -3587,6 +3581,46 @@ def load_gguf_streaming(path : string; mode : QuantMode; var t : Model; var jobs
         set_conv_profile(true)
     }
     let ts_load = ref_time_ticks()
+    let lmode0 = mode
+    var shards <- gguf_shard_paths(path)
+    if (length(shards) > 1) {
+        // split gguf: every shard mapping stays alive across the plan-load AND the blk-save
+        // (the transcode kernels resolve per-shard bases through the meta)
+        to_log(LOG_INFO, "dasLLAMA: split gguf — {length(shards)} shards (streaming)\n")
+        var sok = false
+        var bases : array<void?>
+        var sizes : array<int64>
+        gguf_map_shards(shards, 0, bases, sizes) {
+            if (env_flag("DASLLAMA_PREFETCH", true)) {
+                var pf_mb = 0l
+                for (bi in range(length(bases))) {
+                    if (unsafe(prefetch_map(bases[bi], uint64(sizes[bi])))) {
+                        pf_mb += sizes[bi] >> 20l
+                    }
+                }
+                if (pf_mb > 0l) {
+                    to_log(LOG_INFO, "dasLLAMA: source prefetch armed ({pf_mb} MB across {length(bases)} shards)\n")
+                }
+            }
+            var m <- parse_gguf_meta_shards(bases, sizes)
+            fill_plan_begin()
+            unsafe {
+                load_gguf_parsed(t, m, temp_array(reinterpret<uint8?>(bases[0]), sizes[0], type<uint8>), lmode0, ts_load)
+            }
+            fill_plan_take(jobs)
+            t.tok <- load_tokenizer_auto(path)
+            unsafe {
+                sok = invoke(blk, m, temp_array(reinterpret<uint8?>(bases[0]), sizes[0], type<uint8>))
+            }
+            delete m
+        }
+        bases |> clear()   // borrowed mapping bases — clear so delete frees only the buffer
+        delete bases
+        delete sizes
+        delete shards
+        return sok
+    }
+    delete shards
     let f = fopen(path, "rb")
     if (f == null) {
         return false
@@ -3608,7 +3642,9 @@ def load_gguf_streaming(path : string; mode : QuantMode; var t : Model; var jobs
         load_gguf_parsed(t, m, bytes, lmode, ts_load)
         fill_plan_take(jobs)
         t.tok <- load_tokenizer_auto(path)
-        ok = invoke(blk, m, bytes)
+        unsafe {
+            ok = invoke(blk, m, temp_array(reinterpret<uint8?>(addr(bytes[0])), long_length(bytes), type<uint8>))
+        }
     }
     fclose(f)
     return ok
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 4c3d148fe4..e645c5e7a5 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -288,7 +288,7 @@ def main() : int {
             var mt = Model()
             var jobs : array<FillJob>
             var blk_ran = false
-            let sok = load_gguf_streaming(cfg.model, qm, mt, jobs) $(gm : GGUFMeta; gbytes : array<uint8> const#) {
+            let sok = load_gguf_streaming(cfg.model, qm, mt, jobs) $(gm : GGUFMeta; gbytes : array<uint8>) {
                 blk_ran = true
                 if (empty(jobs)) {
                     to_log(LOG_INFO, "dasllama-convert: streaming unavailable for this model — writing eagerly from RAM\n")

From 8ef54eeaac1a5f1c1588609cd12cdda91c59ca43 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 02:49:20 -0700
Subject: [PATCH 14/30] =?UTF-8?q?dlim=20arc=20phase=20F:=20P2=20imported?=
 =?UTF-8?q?=20mirrors=20=E2=80=94=20import-first=20stream=20mirrors,=20bou?=
 =?UTF-8?q?ndary-exact=20slice=20replay?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The import rail: on a vulkan-flavor load, streamed expert mirrors IMPORT the mapped
image window (VK_EXT_external_memory_host) instead of pinned copies — SliceWindow
table recorded while slicing, moe_gpu_slice_window/unmap_notify seams, Model
finalizer notifies the tier before fmap_close. DASLLAMA_VK_IMPORT=0 forces pinned.

Driver verdict on NVIDIA/Windows (probe-verified, _vk_import_probe.das): anon
WRITABLE imports succeed, READ-ONLY file-backed pages are refused with
ERROR_OUT_OF_DEVICE_MEMORY regardless of memory type — so the import declines
once (named reason), disables for the process, and every stack falls back to
pinned copies. The rail self-enables wherever a driver accepts the mapping.

Fixes found by the 35B gate (budget-bounded model, first slice replay WITH a
refusal boundary):

- Boundary-exact slice replay: the bake records only ACCEPTED gathers, but the
  walk still attempts the one the budget refuses at each stage boundary — the
  slicer now asks the tier's shared would-accept arithmetic (vk_moe_resident_verdict
  via the moe_gpu_would_accept seam) and serves a predicted refusal EMPTY, holding
  the cursor: the walk re-refuses, rolls back, re-syncs. Before this, ANY model
  that didn't fully fit declined to live gathers mid-walk.
- carved_budget(): the stream-slot reserve derives at READ time from the loader's
  reported need — the init-time carve was timing-dependent (the expert_q8n probe
  could init the device before the need was known), which made dry-bake and live
  budgets diverge.
- make_imported_buf is fail-soft end to end (create/props/alloc/bind all checked)
  and prefers the host_cached non-device-local memory type — the lowest usable
  bit can be the ReBAR heap, where multi-GB imports exhaust VRAM.
- make_host_buf grows a soft mode: a pinned-mirror alloc failure now reads as the
  streamed walk's budget stop (roll back, stop streaming) instead of a panic.
- moe_gpu_upload_stack tolerates empty planes (the refusal-boundary serve).

Gate receipts (Qwen3.6-35B Q4_K_M, 6000 MB cap): import-ON and import-OFF runs
produce IDENTICAL 24-token IDS; slice replay consumes the plan exactly (no
regather warning, refusal replays at 4787159040 bytes both sides); resident
[35..40) + streamed [0..35) matches the bake.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/ENVIRONMENT.md               |   1 +
 modules/dasLLAMA/dasllama/dasllama_common.das |  47 +++-
 modules/dasLLAMA/dasllama/dasllama_env.das    |   2 +
 modules/dasLLAMA/dasllama/dasllama_math.das   |  62 ++++-
 .../dasllama/dasllama_math_vulkan.das         | 249 ++++++++++++++++--
 5 files changed, 334 insertions(+), 27 deletions(-)

diff --git a/modules/dasLLAMA/ENVIRONMENT.md b/modules/dasLLAMA/ENVIRONMENT.md
index 5b79446b69..dbdd8122e4 100644
--- a/modules/dasLLAMA/ENVIRONMENT.md
+++ b/modules/dasLLAMA/ENVIRONMENT.md
@@ -96,6 +96,7 @@ Vulkan GPU backend. Present only where the dasVulkan package is installed.
 | `DASLLAMA_MM_SMALLD` | number | 64 | Small-d cutoff routing narrow roles (k/v) to the small tier; widening measured worse, so this is an instrument. |
 | `DASLLAMA_VK_FUSE` | flag | on | Fused decode tail (add+rms+requant, qk-norm+rope); 0 pins the split dispatches for a same-build A/B. |
 | `DASLLAMA_VK_XFERQ` | flag | on | Stream expert uploads on the dedicated transfer queue, overlapped via a timeline semaphore; 0 keeps the single-queue rail. |
+| `DASLLAMA_VK_IMPORT` | flag | on | Stream mirrors import the mapped .dlim (VK_EXT_external_memory_host) instead of pinned copies; =0 restores the copy path. |
 | `DASLLAMA_TRIM` | flag | off | Serve from P3-trimmed vulkan images (big CPU weight families dropped; folded into the flavor identity). |
 | `DASLLAMA_VK_MEMPRIO` | flag | on | Tag allocations high-priority (VK_EXT_memory_priority) so the driver demotes desktop memory, not ours. |
 | `DASLLAMA_VK_FA` | flag | on | Vulkan flash-attention kernel; 0 falls back to the chunked path. |
diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index 9f7e1aa1b6..cc5c08fc5b 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -429,6 +429,28 @@ var private g_vk_bake_plan : array<VkPlanEntry>
 var private g_vk_bake_cursor = 0l
 var private g_vk_bake_role = VkBakeRole.none
 
+// P2 imported mirrors: the mapped-blob window of each sliced gather, keyed woff*8+fmt (the
+// marks convention) — the stream-mirror path imports these instead of copying to pinned RAM
+struct private SliceWindow {
+    wq : void?
+    ws : void?
+    wq_bytes : int64
+    ws_bytes : int64
+}
+
+var private g_vk_slice_windows : table<int64; SliceWindow>
+
+def private vk_slice_window_provider(woff : int64; fmt : int) : MoeGpuSliceWindow {
+    let k = woff * 8l + int64(fmt)
+    if (!key_exists(g_vk_slice_windows, k)) {
+        return default<MoeGpuSliceWindow>
+    }
+    unsafe {
+        let w & = g_vk_slice_windows[k]
+        return (wq = w.wq, ws = w.ws, wqb = w.wq_bytes, wsb = w.ws_bytes)
+    }
+}
+
 //! The upload walk declares its current stage here (collect stamps it, slice verifies it).
 def vulkan_bake_role(r : VkBakeRole) {
     g_vk_bake_role = r
@@ -459,6 +481,7 @@ def vulkan_bake_slice_begin {
     g_vk_bake = VkBakeMode.slice
     g_vk_bake_role = VkBakeRole.none
     g_vk_bake_cursor = 0l
+    g_vk_slice_windows |> clear()
 }
 
 //! Disarm after a successful flavor load; a partially-consumed plan means the walk diverged
@@ -513,19 +536,36 @@ def private vk_bake_slice(t : Model; fmt : int; woff, n, rows : int64;
     if (g_vk_bake != VkBakeMode.slice) {
         return false
     }
-    // plan divergence DECLINES to live gathers mid-walk (seamless: matched entries were byte-identical)
+    // the bake records only ACCEPTED gathers — serve a would-refuse mismatch EMPTY (the refusal is pure arithmetic), hold the cursor: the walk re-refuses, rolls back, and re-syncs with the plan
     if (g_vk_bake_cursor >= long_length(t.vkplan)) {
+        if (!moe_gpu_would_accept(n, rows, fmt, g_vk_bake_role == VkBakeRole.expert_stream)) {
+            wq |> resize(0)
+            ws |> resize(0)
+            return true
+        }
         to_log(LOG_WARNING, "dasLLAMA vulkan image: the GPU walk overran the baked plan at gather {g_vk_bake_cursor} — regathering live from here\n")
         g_vk_bake = VkBakeMode.off
         return false
     }
     let e = t.vkplan[int(g_vk_bake_cursor)]
     if (e.fmt != fmt || e.woff != woff || e.n != n || e.rows != rows || e.role != int(g_vk_bake_role)) {
+        if (!moe_gpu_would_accept(n, rows, fmt, g_vk_bake_role == VkBakeRole.expert_stream)) {
+            wq |> resize(0)
+            ws |> resize(0)
+            return true
+        }
         to_log(LOG_WARNING, "dasLLAMA vulkan image: baked gather {g_vk_bake_cursor} is (fmt {e.fmt} role {e.role} woff {e.woff} {e.n}x{e.rows}), the walk wants (fmt {fmt} role {int(g_vk_bake_role)} woff {woff} {n}x{rows}) — regathering live from here\n")
         g_vk_bake = VkBakeMode.off
         return false
     }
     g_vk_bake_cursor++
+    // record the mapped window (P2: the stream-mirror path imports it instead of copying)
+    unsafe {
+        g_vk_slice_windows |> insert(e.woff * 8l + int64(fmt), SliceWindow(
+            wq = e.wq_bytes > 0l ? addr<void?>(t.vkblob[e.wq_off]) : null,
+            ws = e.ws_bytes > 0l ? addr<void?>(t.vkblob[e.ws_off]) : null,
+            wq_bytes = e.wq_bytes, ws_bytes = e.ws_bytes))
+    }
     // int-indexed destinations: a >2GB plane would resize truncated and then memcpy past it
     assert(e.wq_bytes <= 2_147_483_647l && e.ws_bytes <= 2_147_483_647l,
         "vulkan image: a baked plane exceeds the int-indexed array cap")
@@ -1081,6 +1121,8 @@ def finalize(var t : Model) {
         }
     }
     if (t.image_map != null) {
+        // imported device memory over this mapping (P2 mirrors) must release BEFORE the unmap
+        moe_gpu_unmap_notify(t.image_map, t.image_bytes)
         unsafe {
             fmap_close(t.image_map, t.image_bytes)
         }
@@ -2223,6 +2265,7 @@ def private dlim_metal_source_impl(var c : DlimMetalConfig) : bool {
 def dlim_config_sources_register() {
     set_dlim_cpu_source(@@dlim_cpu_source_impl)
     set_dlim_metal_source(@@dlim_metal_source_impl)
+    set_moe_gpu_slice_window_fn(@@vk_slice_window_provider)
 }
 
 def private count_fmt(a : array<KqFmt>; f : KqFmt) : int {
@@ -3643,7 +3686,7 @@ def load_gguf_streaming(path : string; mode : QuantMode; var t : Model; var jobs
         fill_plan_take(jobs)
         t.tok <- load_tokenizer_auto(path)
         unsafe {
-            ok = invoke(blk, m, temp_array(reinterpret<uint8?>(addr(bytes[0])), long_length(bytes), type<uint8>))
+            ok = invoke(blk, m, temp_array(addr<uint8?>(bytes[0]), long_length(bytes), type<uint8>))
         }
     }
     fclose(f)
diff --git a/modules/dasLLAMA/dasllama/dasllama_env.das b/modules/dasLLAMA/dasllama/dasllama_env.das
index 91aeeb1b47..a285b54a1c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_env.das
+++ b/modules/dasLLAMA/dasllama/dasllama_env.das
@@ -231,6 +231,8 @@ def private reg_vulkan(var o : array<EnvKnob>) {
       "Stream expert uploads on the dedicated transfer queue, overlapped via a timeline semaphore; 0 keeps the single-queue rail.")
     k(o, "DASLLAMA_PREFETCH", EnvKind.flag, EnvArea.engine, "on",
       "Advisory source-mapping readahead at gguf load (cold-conversion fix); =0 restores on-demand faulting.")
+    k(o, "DASLLAMA_VK_IMPORT", EnvKind.flag, EnvArea.vulkan, "on",
+      "Stream mirrors import the mapped .dlim (VK_EXT_external_memory_host) instead of pinned copies; =0 restores the copy path.")
     k(o, "DASLLAMA_TRIM", EnvKind.flag, EnvArea.vulkan, "off",
       "Serve from P3-trimmed vulkan images (big CPU weight families dropped; folded into the flavor identity).")
     k(o, "DASLLAMA_VK_MEMPRIO", EnvKind.flag, EnvArea.vulkan, "on",
diff --git a/modules/dasLLAMA/dasllama/dasllama_math.das b/modules/dasLLAMA/dasllama/dasllama_math.das
index 3a09dab5ce..30da6a07b6 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math.das
@@ -2185,6 +2185,56 @@ def public set_moe_gpu_dry_bake_arm(f : function<(v : DlimVulkanConfig) : bool>)
 //! this process' env wants — the tier logs the exact mismatch).
 def public moe_gpu_dry_bake_arm(v : DlimVulkanConfig) : bool => invoke(g_moe_gpu_dry_bake, v)
 
+//! A baked-plan gather's mapped-file window (P2 imported mirrors): pointers into the flavor
+//! image's mapping + plane byte sizes. wq == null = no window recorded for (woff, fmt).
+typedef MoeGpuSliceWindow = tuple<wq : void?; ws : void?; wqb : int64; wsb : int64>
+
+[unused_argument(woff, fmt)]
+def private moe_gpu_no_slice_window(woff : int64; fmt : int) : MoeGpuSliceWindow {
+    return default<MoeGpuSliceWindow>
+}
+
+var private g_moe_gpu_slice_window = @@moe_gpu_no_slice_window
+
+//! The loader registers its slice-window provider (populated while slicing a flavor image);
+//! a GPU tier asks through [[moe_gpu_slice_window]] to import instead of copying.
+def public set_moe_gpu_slice_window_fn(f : function<(woff : int64; fmt : int) : MoeGpuSliceWindow>) {
+    g_moe_gpu_slice_window = f
+}
+
+def public moe_gpu_slice_window(woff : int64; fmt : int) : MoeGpuSliceWindow => invoke(g_moe_gpu_slice_window, woff, fmt)
+
+[unused_argument(base, bytes)]
+def private moe_gpu_no_unmap_notify(base : void?; bytes : uint64) {}
+
+var private g_moe_gpu_unmap_notify = @@moe_gpu_no_unmap_notify
+
+//! A GPU tier registers this to learn a model's mapping is about to unmap — imported device
+//! memory over that mapping must be released FIRST (the Model finalizer invokes it).
+def public set_moe_gpu_unmap_notify(f : function<(base : void?; bytes : uint64) : void>) {
+    g_moe_gpu_unmap_notify = f
+}
+
+def public moe_gpu_unmap_notify(base : void?; bytes : uint64) {
+    invoke(g_moe_gpu_unmap_notify, base, bytes)
+}
+
+[unused_argument(n, rows, fmt, stream)]
+def private moe_gpu_always_accept(n : int64; rows : int64; fmt : int; stream : bool) : bool => true
+
+var private g_moe_gpu_would_accept = @@moe_gpu_always_accept
+
+//! A GPU tier registers its accept arithmetic (no side effects). The slice replay asks through
+//! [[moe_gpu_would_accept]] whether a gather the plan lacks is a refusal boundary — the bake
+//! never records refused gathers, so the walk's boundary attempt must re-refuse, not diverge.
+def public set_moe_gpu_would_accept_fn(f : function<(n : int64; rows : int64; fmt : int; stream : bool) : bool>) {
+    g_moe_gpu_would_accept = f
+}
+
+def public moe_gpu_would_accept(n : int64; rows : int64; fmt : int; stream : bool) : bool {
+    return invoke(g_moe_gpu_would_accept, n, rows, fmt, stream)
+}
+
 def private moe_gpu_no_bake_tag : string => ""
 
 var private g_moe_gpu_bake_tag = @@moe_gpu_no_bake_tag
@@ -2272,13 +2322,17 @@ def public moe_gpu_upload_stack(wq : array<uint8> | #; ws : array<uint8> | #; wo
     if (!g_moe_gpu_installed) {
         return false
     }
-    var wsp : uint8 const?   // q8n stacks carry no scale plane — an empty ws hands the tier null
+    // empty planes hand the tier null: q8n stacks carry no scale plane, and the slice replay's
+    // refusal-boundary serve is empty on purpose (the tier refuses on arithmetic, no bytes read)
+    var wqp : uint8 const?
+    if (!empty(wq)) {
+        wqp = unsafe(addr<uint8 const?>(wq[0]))
+    }
+    var wsp : uint8 const?
     if (!empty(ws)) {
         wsp = unsafe(addr<uint8 const?>(ws[0]))
     }
-    unsafe {
-        return invoke(g_moe_gpu_upload, addr<uint8 const?>(wq[0]), wsp, woff, n, rows, fmt, stream)
-    }
+    return invoke(g_moe_gpu_upload, wqp, wsp, woff, n, rows, fmt, stream)
 }
 
 //! Fused MoE FFN on the GPU tier — the whole gate+up -> act -> requant -> down chain of the
diff --git a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
index 2ec036b588..4760dad429 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
@@ -4200,7 +4200,7 @@ def private find_host_mem(type_bits : uint; cached : bool) : uint {
     return find_memory_type(g_gpu.phys, type_bits, want)
 }
 
-def private make_host_buf(bytes : int64; storage : bool; cached : bool = false; xfer_shared : bool = false) : HostBuf {
+def private make_host_buf(bytes : int64; storage : bool; cached : bool = false; xfer_shared : bool = false; soft : bool = false) : HostBuf {
     var bci : BufferCreateInfo
     bci.size = uint64(bytes)
     bci.usage.storage_buffer = storage
@@ -4215,7 +4215,19 @@ def private make_host_buf(bytes : int64; storage : bool; cached : bool = false;
     let req = get_buffer_memory_requirements(g_gpu.device, b)
     let mai = MemoryAllocateInfo(allocationSize = req.size,
                                  memoryTypeIndex = find_host_mem(req.memoryTypeBits, cached))
-    var m <- allocate_memory(g_gpu.device, mai)
+    var ares = VkResult.SUCCESS
+    var m <- allocate_memory(g_gpu.device, mai, unsafe(addr(ares)))
+    if (ares != VkResult.SUCCESS) {
+        // soft callers (stream mirrors) degrade — the walk treats it as its budget stop
+        if (!soft) {
+            panic("dasLLAMA vulkan tier: pinned host alloc failed ({ares}, {bytes} bytes, type {mai.memoryTypeIndex})")
+        }
+        to_log(LOG_INFO, "dasLLAMA vulkan tier: pinned mirror alloc declined ({ares}, {bytes} bytes, type {mai.memoryTypeIndex}) — streamed walk stops here\n")
+        unsafe {
+            vkDestroyBuffer(dev_raw(), reinterpret<VkBuffer>(b._vk), null)
+        }
+        return HostBuf()
+    }
     bind_buffer_memory(g_gpu.device, b, m, 0ul)
     var mapped : void? = null
     let mf : VkMemoryMapFlags
@@ -4392,18 +4404,20 @@ def private resolve_weight_cap(heap : VkHeapInfo) : int64 {
     return cap
 }
 
-// stream-slot carve: exact loader-reported need, else the legacy constant (direct-upload paths).
-// One helper — the dry init must carve exactly as the live one does.
-def private carve_stream_reserve {
+// The stream-slot carve, derived AT READ TIME — g_gpu.weight_budget stores the UNCARVED cap.
+// Init-time carving was timing-dependent (the expert_q8n probe can init the device BEFORE the
+// loader reports its slot need), which made a dry bake's plan diverge from the live walk's.
+def private carved_budget : int64 {
+    var r = g_gpu.weight_budget
     if (gpu_want_moe_stream() != 0l) {
         let need = moe_gpu_stream_need()
         if (need > 0l) {
-            g_gpu.stream_reserve = 2l * need
+            r -= 2l * need
         } elif (gpu_want_moe_stream() > 0l) {
-            g_gpu.stream_reserve = STREAM_RESERVE
+            r -= STREAM_RESERVE
         }
-        g_gpu.weight_budget = max(g_gpu.weight_budget - g_gpu.stream_reserve, 0l)
     }
+    return max(r, 0l)
 }
 
 var private g_vk_dry_want = false
@@ -4470,7 +4484,7 @@ def private vk_moe_init : bool {
         g_gpu.rows_per_wg = int64((WG_X + uint(g_vk_dry_cfg.subgroup_size) - 1u) / uint(g_vk_dry_cfg.subgroup_size))
         g_gpu.msr = g_vk_dry_cfg.max_storage_range
         g_gpu.weight_budget = g_vk_dry_cfg.vram_mb * 1_000_000l
-        carve_stream_reserve()
+
         return true
     }
     g_init_failed = true   // cleared only on full success
@@ -4563,7 +4577,7 @@ def private vk_moe_init : bool {
         }
         to_log(LOG_INFO, "dasLLAMA vulkan tier: device heap budget {heap.budget / 1000000l} MB (used {heap.used / 1000000l}), weight cap {g_gpu.weight_budget / 1000000l} MB\n")
     }
-    carve_stream_reserve()
+
     // ReBAR: DL|HV|HC on the full-VRAM heap (the >1GB check excludes the 256MiB legacy window)
     if (env_flag("DASLLAMA_VK_REBAR", true)) {
         var rmp : VkPhysicalDeviceMemoryProperties
@@ -4783,14 +4797,158 @@ def private ensure_gemv_scratch(si : int) {
     g_gpu.stacks[si].gemv_made = true
 }
 
-// stream arm: keep the gathered device-layout planes in a pinned host mirror (host-visible
-// memory the copy engine DMA-streams into a slot per prefill). No VRAM spent here.
+// import support is spec-gray per driver: one decline disables imports for the process (say WHY
+// once) — every later stack goes straight to the pinned copy instead of churning failed vk calls
+def private vk_import_declined(why : string) {
+    if (!g_vk_import_declined_said) {
+        g_vk_import_declined_said = true
+        to_log(LOG_INFO, "dasLLAMA vulkan tier: mapped-image import declined ({why}) — pinned mirror copies\n")
+    }
+}
+
+// P2: import a 4KB-aligned mapped-file window as a transfer_src buffer (VK_EXT_external_memory_host).
+// buf == 0 = declined, the caller falls back to the pinned copy — NVIDIA/Windows refuses READ-ONLY
+// file-backed pages (anon writable imports succeed; probe-verified 2026-07-28, _vk_import_probe.das)
+def private make_imported_buf(ptr : void?; bytes : int64) : HostBuf {
+    let hb = HostBuf()
+    if (ptr == null || bytes <= 0l || !device_extension_available(g_gpu.phys, "VK_EXT_external_memory_host")) {
+        return hb
+    }
+    let algn = int64(external_memory_host_min_alignment(g_gpu.phys))
+    if (algn <= 0l || int64(intptr(ptr)) % algn != 0l) {
+        return hb
+    }
+    // the round-up stays inside the mapping: windows start 4KB-aligned, the file is 16KB-padded
+    let sz = (bytes + algn - 1l) / algn * algn
+    var ht : VkExternalMemoryHandleTypeFlags
+    ht.host_allocation_ext = true
+    var hpp = VkMemoryHostPointerPropertiesEXT()
+    let hres = vkGetMemoryHostPointerPropertiesEXT(dev_raw(), ht, ptr, hpp)
+    if (hres != VkResult.SUCCESS) {
+        vk_import_declined("vkGetMemoryHostPointerPropertiesEXT {hres}")
+        return hb
+    }
+    var emb = VkExternalMemoryBufferCreateInfo()
+    emb.handleTypes = ht
+    var bci : BufferCreateInfo
+    bci.size = uint64(sz)
+    bci.usage.transfer_src = true
+    if (g_gpu.xfer_fam >= 0) {
+        // same CONCURRENT sharing the pinned mirrors use (transfer-queue fills + compute heat slices)
+        bci.sharingMode = VkSharingMode.CONCURRENT
+        bci.pQueueFamilyIndices <- [g_gpu.fam, uint(g_gpu.xfer_fam)]
+    }
+    unsafe {
+        bci.next = addr<void?>(emb)
+    }
+    var cres = VkResult.SUCCESS
+    var b <- create_buffer(g_gpu.device, bci, unsafe(addr(cres)))   // deliberately never finalized (make_host_buf's rule)
+    if (cres != VkResult.SUCCESS) {
+        vk_import_declined("vkCreateBuffer {cres}")
+        return hb
+    }
+    let req = get_buffer_memory_requirements(g_gpu.device, b)
+    let usable = hpp.memoryTypeBits & req.memoryTypeBits
+    if (usable == 0u || int64(req.size) > sz) {
+        unsafe {
+            vkDestroyBuffer(dev_raw(), reinterpret<VkBuffer>(b._vk), null)
+        }
+        vk_import_declined(usable == 0u ? "no usable memory type" : "buffer wants {req.size} bytes over a {sz} byte window")
+        return hb
+    }
+    // prefer host_cached NON-device-local: the lowest usable bit can be the ReBAR heap (multi-GB imports exhaust VRAM), and imported file pages are cached RAM — an attribute mismatch is a driver refusal
+    var mp : VkPhysicalDeviceMemoryProperties
+    vkGetPhysicalDeviceMemoryProperties(g_gpu.phys, mp)
+    var ti = 0u
+    while ((usable & (1u << ti)) == 0u) {
+        ti++
+    }
+    var plain = -1
+    var cached = -1
+    for (i in range(int(mp.memoryTypeCount))) {
+        let fl = mp.memoryTypes[i].propertyFlags
+        if ((usable & (1u << uint(i))) != 0u && fl.host_visible && !fl.device_local) {
+            plain = plain < 0 ? i : plain
+            cached = cached < 0 && fl.host_cached ? i : cached
+        }
+    }
+    if (cached >= 0) {
+        ti = uint(cached)
+    } elif (plain >= 0) {
+        ti = uint(plain)
+    }
+    var imp = VkImportMemoryHostPointerInfoEXT()
+    imp.handleType = ht
+    imp.pHostPointer = ptr
+    var mai = MemoryAllocateInfo(allocationSize = uint64(sz), memoryTypeIndex = ti)
+    unsafe {
+        mai.next = addr<void?>(imp)
+    }
+    var ares = VkResult.SUCCESS
+    var m <- allocate_memory(g_gpu.device, mai, unsafe(addr(ares)))
+    if (ares != VkResult.SUCCESS) {
+        unsafe {
+            vkDestroyBuffer(dev_raw(), reinterpret<VkBuffer>(b._vk), null)
+        }
+        vk_import_declined("vkAllocateMemory {ares}, type {ti} of usable {usable} ({mp.memoryTypes[int(ti)].propertyFlags}), {sz} bytes")
+        return hb
+    }
+    var bres = VkResult.SUCCESS
+    bind_buffer_memory(g_gpu.device, b, m, 0ul, unsafe(addr(bres)))
+    if (bres != VkResult.SUCCESS) {
+        unsafe {
+            vkFreeMemory(dev_raw(), reinterpret<VkDeviceMemory>(m._vk), null)
+            vkDestroyBuffer(dev_raw(), reinterpret<VkBuffer>(b._vk), null)
+        }
+        vk_import_declined("vkBindBufferMemory {bres}")
+        return hb
+    }
+    g_gpu.host_mem |> insert(b._vk, m._vk)
+    return HostBuf(buf = b._vk, mem = m._vk, mapped = ptr, bytes = bytes)
+}
+
+// stream arm: pinned host mirror the copy engine DMAs into a slot per prefill (no VRAM spent); P2: a flavor load IMPORTS the gather's mapped-blob window instead — zero pinned RAM, the page cache is the mirror
 def private vk_moe_stream_stack(wq : uint8 const?; ws : uint8 const?; woff : int64; n, rows : int64; fmt : int) : bool {
     let pb = stack_plane_bytes(n, rows, fmt)
+    if (env_flag("DASLLAMA_VK_IMPORT", true) && !g_vk_import_declined_said) {
+        let win = moe_gpu_slice_window(woff, fmt)
+        if (win.wq != null && win.wqb == pb.wq && (pb.ws <= 0l || (win.ws != null && win.wsb == pb.ws))) {
+            var iq = make_imported_buf(win.wq, pb.wq)
+            if (iq.buf != 0ul) {
+                // ws: import the real window, or a tiny pinned dummy for the descriptor floor (q8n)
+                let is_ = pb.ws > 0l ? make_imported_buf(win.ws, pb.ws) : make_host_buf(64l, false, [xfer_shared = true])
+                if (is_.buf != 0ul) {
+                    var ss = StreamStack(base = woff, elems = rows * n, fmt = fmt,
+                                         wqbytes = pb.wq, wsbytes = pb.ws, hwq = iq, hws = is_)
+                    if (length(g_gpu.stream_stacks) % 3 == 2) {
+                        g_gpu.stream_max_dn_wq = max(g_gpu.stream_max_dn_wq, pb.wq)
+                        g_gpu.stream_max_dn_ws = max(g_gpu.stream_max_dn_ws, pb.ws)
+                    } else {
+                        g_gpu.stream_max_gu_wq = max(g_gpu.stream_max_gu_wq, pb.wq)
+                        g_gpu.stream_max_gu_ws = max(g_gpu.stream_max_gu_ws, pb.ws)
+                    }
+                    g_gpu.stream_stacks |> emplace(ss)
+                    if (!g_vk_import_said) {
+                        g_vk_import_said = true
+                        to_log(LOG_INFO, "dasLLAMA vulkan tier: stream mirrors IMPORT the mapped image (external_memory_host) — zero pinned copies\n")
+                    }
+                    return true
+                }
+                destroy_host_buf(iq)
+            }
+        }
+    }
     var ss = StreamStack(base = woff, elems = rows * n, fmt = fmt, wqbytes = pb.wq, wsbytes = pb.ws)
     if (!g_gpu.dry) {
-        ss.hwq = make_host_buf(pb.wq, false, [xfer_shared = true])
-        ss.hws = make_host_buf(max(pb.ws, 64l), false, [xfer_shared = true])
+        ss.hwq = make_host_buf(pb.wq, false, [xfer_shared = true, soft = true])
+        if (ss.hwq.buf == 0ul) {
+            return false   // pinned-mirror stop: the walk rolls the partial triple back and breaks
+        }
+        ss.hws = make_host_buf(max(pb.ws, 64l), false, [xfer_shared = true, soft = true])
+        if (ss.hws.buf == 0ul) {
+            destroy_host_buf(ss.hwq)
+            return false
+        }
         unsafe {
             par_memcpy(ss.hwq.mapped, reinterpret<void?>(wq), pb.wq)
             if (pb.ws > 0l) {   // q8n mirrors carry no scale plane
@@ -4809,6 +4967,27 @@ def private vk_moe_stream_stack(wq : uint8 const?; ws : uint8 const?; woff : int
     return true
 }
 
+// The resident-accept arithmetic, shared by the upload path and the slice replay's would-accept
+// probe — a divergent copy would desync the baked plan at the refusal boundary.
+// 0 = accept, 1 = VRAM budget, 2 = descriptor capacity.
+def private vk_moe_resident_verdict(n, rows : int64; fmt : int) : int {
+    let pb = stack_plane_bytes(n, rows, fmt)
+    if (g_gpu.resident_bytes + pb.wq + pb.ws > carved_budget()) {
+        return 1
+    }
+    return length(g_gpu.stacks) >= MAX_STACKS ? 2 : 0
+}
+
+//! MoeGpuWouldAcceptFn: would the tier accept this stack right now? Pure arithmetic, no side
+//! effects — the slice replay uses it to distinguish a refusal boundary (the walk attempts a
+//! gather the bake refused, so it is NOT in the plan) from real plan divergence.
+def vk_moe_would_accept(n : int64; rows : int64; fmt : int; stream : bool) : bool {
+    if (g_gpu == null) {
+        return true   // tier not up: claim accept so a mismatch reads as real divergence
+    }
+    return stream || vk_moe_resident_verdict(n, rows, fmt) == 0
+}
+
 //! MoeGpuUploadFn: upload one weight stack ([rows x n] at element offset woff) from the loader's
 //! gathered row-major planes. stream = pinned host mirror for per-prefill DMA instead of VRAM.
 def vk_moe_upload_stack(wq : uint8 const?; ws : uint8 const?; woff : int64; n : int64; rows : int64; fmt : int; stream : bool) : bool {
@@ -4818,17 +4997,18 @@ def vk_moe_upload_stack(wq : uint8 const?; ws : uint8 const?; woff : int64; n :
     if (stream) {
         return vk_moe_stream_stack(wq, ws, woff, n, rows, fmt)
     }
-    let pb = stack_plane_bytes(n, rows, fmt)
-    let wqbytes = pb.wq
-    let wsbytes = pb.ws
-    if (g_gpu.resident_bytes + wqbytes + wsbytes > g_gpu.weight_budget) {
+    let verdict = vk_moe_resident_verdict(n, rows, fmt)
+    if (verdict == 1) {
         to_log(LOG_INFO, "dasLLAMA vulkan tier: VRAM budget reached at {g_gpu.resident_bytes} bytes\n")
         return false
     }
-    if (length(g_gpu.stacks) >= MAX_STACKS) {
+    if (verdict == 2) {
         to_log(LOG_INFO, "dasLLAMA vulkan tier: descriptor capacity reached at {length(g_gpu.stacks)} stacks\n")
         return false
     }
+    let pb = stack_plane_bytes(n, rows, fmt)
+    let wqbytes = pb.wq
+    let wsbytes = pb.ws
     let si = make_stack_shell(woff, rows * n, fmt, wqbytes, wsbytes)
     if (!g_gpu.dry) {
         upload_region(g_gpu.stacks[si].wqbuf, wq, wqbytes)
@@ -8565,7 +8745,7 @@ def private heat_pool_make(l : int64; b1, b3, b2 : int64; f1, f3, f2 : int; n, n
     let pb3 = stack_plane_bytes(n, nfe, f3)
     let pb2 = stack_plane_bytes(nfe, n, f2)
     let per_slot = pb1.wq + pb1.ws + pb3.wq + pb3.ws + pb2.wq + pb2.ws
-    let c = min(want, (g_gpu.weight_budget - g_gpu.resident_bytes) / per_slot)
+    let c = min(want, (carved_budget() - g_gpu.resident_bytes) / per_slot)
     if (c <= 0l) {
         to_log(LOG_INFO, "dasLLAMA vulkan tier: heat cache skips layer {l} (VRAM budget)\n")
         g_gpu.heat_pools[l] <- pool
@@ -8919,6 +9099,31 @@ def vk_moe_cls(var yp : float?; woff : int64; xqp : int8 const?; xsp : float con
 
 // ===== registration =====
 
+var private g_vk_import_said = false   // one import proof-line per process
+var private g_vk_import_declined_said = false
+
+// MoeGpuUnmapNotifyFn: a model's mapping is about to unmap — release imported device memory
+// over it FIRST (reading through a freed import faults the device). Whole-model teardown: the
+// single-owner tier's stream mirrors all belong to the unmapping model when any hit the range.
+def private vk_unmap_notify(base : void?; bytes : uint64) {
+    if (g_gpu == null || g_gpu.dry || base == null) {
+        return
+    }
+    var hit = false
+    let b0 = intptr(base)
+    for (ss in g_gpu.stream_stacks) {
+        let p = intptr(ss.hwq.mapped)
+        if (p >= b0 && p < b0 + bytes) {
+            hit = true
+            break
+        }
+    }
+    if (hit) {
+        to_log(LOG_INFO, "dasLLAMA vulkan tier: model unmapping — dropping imported stream mirrors first\n")
+        vk_drop_model_state()
+    }
+}
+
 var private g_vk_probed = false
 var private g_vk_available = false
 var private g_vk_why = ""   // why the device probe said no — discarded before, which made it silent
@@ -8973,7 +9178,7 @@ def private vk_resident_bytes : int64 => g_gpu != null ? g_gpu.resident_bytes :
 // The resident driver sizes a whole model against these BEFORE uploading anything. Probing the
 // device here (rather than reporting 0 until something else arms it) is what lets the gate answer
 // "would this fit?" on a cold tier.
-def private vk_weight_budget : int64 => vk_moe_init() ? g_gpu.weight_budget : 0l
+def private vk_weight_budget : int64 => vk_moe_init() ? carved_budget() : 0l
 
 def private vk_plane_bytes(n, rows : int64; fmt : int) : int64 {
     let pb = stack_plane_bytes(n, rows, fmt)
@@ -9085,6 +9290,8 @@ def dasllama_math_vulkan_register() {
     set_moe_gpu_bake_tag(@@vk_bake_tag)
     set_dlim_vulkan_source(@@vk_dlim_source)
     set_moe_gpu_dry_bake_arm(@@vulkan_dry_bake_arm)
+    set_moe_gpu_unmap_notify(@@vk_unmap_notify)
+    set_moe_gpu_would_accept_fn(@@vk_moe_would_accept)
     set_moe_gpu_vram_report(@@vk_resident_bytes)
     set_moe_gpu_device_report(@@vk_device_name)
     set_moe_gpu_budget_hooks(@@vk_weight_budget, @@vk_plane_bytes)

From a3f79094c2b7b9eb07faa75cd1a7393401c9c591 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 03:06:45 -0700
Subject: [PATCH 15/30] =?UTF-8?q?dlim=20arc=20phase=20D=20remainder:=20dwr?=
 =?UTF-8?q?ite=20async=20writer=20=E2=80=94=20double-buffered=20bands=20ov?=
 =?UTF-8?q?erlap=20transcode=20and=20device=20time?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

DasDirectWriter grows a second band and a lazily-spawned writer thread: a full
band hands off to the thread while the caller stages into the other, so the
converter's transcode work and the device write overlap instead of serializing.
One job in flight, handed off in order — the strictly-ascending cursor NTFS's
valid-data-length watermark demands is preserved. The aligned-bulk direct path
stays synchronous (the caller may retire its pointer the moment append returns)
after draining the in-flight band. Async failures land in the writer's ok state
at the next append/commit/close; band2 allocation failure falls back to the old
synchronous flush. das API and call sites unchanged.

Gates (busy box): streamed and eager conversions reproduce the banked SHA256
byte-for-byte — Q4_K_M 2323ebec…34e7 (eager AND streamed), Q8_0 96b97b33…af01;
fio suite 194 tests 0 failed. Indicative only (unjudged): streamed planes write
377 -> 564 MB/s (Q4KM) / 712 MB/s (Q8), eager 1500 -> 1627 MB/s. The judged GLM
wall-clock A/B waits for the quiet box.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 src/builtin/module_builtin_fio.cpp | 111 +++++++++++++++++++++++++++--
 1 file changed, 104 insertions(+), 7 deletions(-)

diff --git a/src/builtin/module_builtin_fio.cpp b/src/builtin/module_builtin_fio.cpp
index 7965490f6c..e587649314 100644
--- a/src/builtin/module_builtin_fio.cpp
+++ b/src/builtin/module_builtin_fio.cpp
@@ -2624,11 +2624,19 @@ bool das_dwrite_close ( void * ) { return false; }
 
 #else
 
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+
 // The bounce buffer is what makes the API take any pointer at any size: FILE_FLAG_NO_BUFFERING
 // demands sector-aligned buffer, offset AND count, and O_DIRECT-class paths elsewhere want the
 // same. Re-blocking costs one memcpy at memory bandwidth against a ~2 GB/s device — noise.
+// Two bands double-buffer: a full band flushes on a writer thread while the caller stages the
+// other, so transcode and device time overlap. One job in flight, handed off in order — the
+// strictly-ascending cursor the NTFS valid-data-length watermark demands is preserved.
 struct DasDirectWriter {
     uint8_t *   band = nullptr;
+    uint8_t *   band2 = nullptr;   // the async double-buffer; null = synchronous fallback
     uint64_t    band_bytes = 0;
     uint64_t    fill = 0;          // bytes currently staged in `band`
     uint64_t    written = 0;       // bytes handed to the OS so far
@@ -2641,6 +2649,13 @@ struct DasDirectWriter {
     uint64_t    write_ns = 0;
     uint64_t    direct_bytes = 0;  // bypassed the band (already aligned)
     uint64_t    bounce_bytes = 0;  // staged through the band
+    std::thread writer;            // spawned lazily on the first full band
+    std::mutex  mtx;
+    std::condition_variable cv;
+    const uint8_t * job_src = nullptr;   // the one in-flight async write (null = idle)
+    uint64_t    job_bytes = 0;
+    bool        quit = false;
+    bool        async_fail = false;
 #if _WIN32
     HANDLE      h = INVALID_HANDLE_VALUE;
     wchar_t *   wpath = nullptr;   // kept for the close-time truncate (NO_BUFFERING can't set EOF)
@@ -2649,6 +2664,9 @@ struct DasDirectWriter {
 #endif
 };
 
+static bool das_dwrite_wait_async ( DasDirectWriter * w );
+static void das_dwrite_join_async ( DasDirectWriter * w );
+
 static const uint64_t DAS_DWRITE_DEFAULT_BAND = 16u << 20;
 
 static inline uint64_t das_dwrite_now_ns () {
@@ -2701,6 +2719,8 @@ void * das_dwrite_open ( const char * path, uint64_t total_bytes, uint64_t band_
         delete w;
         return nullptr;
     }
+    // the async double-buffer; when this fails the writer just stays synchronous
+    w->band2 = (uint8_t *) VirtualAlloc(nullptr, (SIZE_T) w->band_bytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
     return w;
 }
 
@@ -2721,6 +2741,7 @@ static bool das_dwrite_raw ( DasDirectWriter * w, const uint8_t * src, uint64_t
 bool das_dwrite_close ( void * hh ) {
     DasDirectWriter * w = (DasDirectWriter *) hh;
     if ( !w ) return false;
+    das_dwrite_join_async(w);   // the in-flight band lands (or fails into w->ok) before the tail
     uint64_t final_bytes = w->written + w->fill;
     if ( w->ok && w->fill ) {
         // the tail: pad to a sector so NO_BUFFERING accepts it, then truncate below
@@ -2746,6 +2767,7 @@ bool das_dwrite_close ( void * hh ) {
         }
     }
     VirtualFree(w->band, 0, MEM_RELEASE);
+    if ( w->band2 ) VirtualFree(w->band2, 0, MEM_RELEASE);
     free(w->wpath);
     delete w;
     return ok;
@@ -2770,6 +2792,8 @@ void * das_dwrite_open ( const char * path, uint64_t total_bytes, uint64_t band_
         delete w;
         return nullptr;
     }
+    // the async double-buffer; when this fails the writer just stays synchronous
+    w->band2 = (uint8_t *) malloc((size_t) w->band_bytes);
 #if defined(__APPLE__)
     fcntl(fd, F_NOCACHE, 1);            // the APFS/HFS equivalent of NO_BUFFERING
     if ( total_bytes ) {
@@ -2813,6 +2837,7 @@ static bool das_dwrite_raw ( DasDirectWriter * w, const uint8_t * src, uint64_t
 bool das_dwrite_close ( void * hh ) {
     DasDirectWriter * w = (DasDirectWriter *) hh;
     if ( !w ) return false;
+    das_dwrite_join_async(w);   // the in-flight band lands (or fails into w->ok) before the tail
     uint64_t final_bytes = w->written + w->fill;
     if ( w->ok && w->fill ) {
         w->ok = das_dwrite_raw(w, w->band, w->fill);
@@ -2822,12 +2847,82 @@ bool das_dwrite_close ( void * hh ) {
     if ( ok && ftruncate(w->fd, (off_t) final_bytes) != 0 ) ok = false;
     close(w->fd);
     free(w->band);
+    free(w->band2);
     delete w;
     return ok;
 }
 
 #endif
 
+// the writer thread: one job in flight at a time, handed off in order — the async half of the
+// double-buffer. Owns w->written and write_ns while a job runs (the caller waits before touching).
+static void das_dwrite_thread ( DasDirectWriter * w ) {
+    std::unique_lock<std::mutex> lk(w->mtx);
+    for ( ;; ) {
+        w->cv.wait(lk, [&]{ return w->job_src != nullptr || w->quit; });
+        if ( w->job_src ) {
+            const uint8_t * src = w->job_src;
+            uint64_t bytes = w->job_bytes;
+            lk.unlock();
+            uint64_t t0 = das_dwrite_now_ns();
+            bool wok = das_dwrite_raw(w, src, bytes);
+            uint64_t dt = das_dwrite_now_ns() - t0;
+            lk.lock();
+            w->write_ns += dt;
+            if ( !wok ) w->async_fail = true;
+            w->job_src = nullptr;
+            w->cv.notify_all();
+            continue;
+        }
+        if ( w->quit ) break;
+    }
+}
+
+// drain the in-flight band; false = the async write failed (the writer is broken)
+static bool das_dwrite_wait_async ( DasDirectWriter * w ) {
+    if ( !w->writer.joinable() ) return !w->async_fail;
+    std::unique_lock<std::mutex> lk(w->mtx);
+    w->cv.wait(lk, [&]{ return w->job_src == nullptr; });
+    return !w->async_fail;
+}
+
+// close-time retirement: drain, stop, join; an async failure lands in w->ok
+static void das_dwrite_join_async ( DasDirectWriter * w ) {
+    if ( !das_dwrite_wait_async(w) ) w->ok = false;
+    if ( w->writer.joinable() ) {
+        {
+            std::lock_guard<std::mutex> g(w->mtx);
+            w->quit = true;
+        }
+        w->cv.notify_all();
+        w->writer.join();
+    }
+}
+
+// a full band: hand it to the writer thread and keep staging into the other; without the second
+// band (alloc failed) flush synchronously exactly as before
+static bool das_dwrite_flush_full_band ( DasDirectWriter * w ) {
+    if ( w->band2 ) {
+        if ( !das_dwrite_wait_async(w) ) return false;
+        if ( !w->writer.joinable() ) w->writer = std::thread(das_dwrite_thread, w);
+        {
+            std::lock_guard<std::mutex> g(w->mtx);
+            w->job_src = w->band;
+            w->job_bytes = w->band_bytes;
+        }
+        w->cv.notify_all();
+        std::swap(w->band, w->band2);
+        w->fill = 0;
+        return true;
+    }
+    uint64_t t0 = das_dwrite_now_ns();
+    bool wok = das_dwrite_raw(w, w->band, w->band_bytes);
+    w->write_ns += das_dwrite_now_ns() - t0;
+    if ( !wok ) return false;
+    w->fill = 0;
+    return true;
+}
+
 // platform-independent half: stage into the band, push whenever it fills. A writer that has
 // already failed stays failed and stops touching the disk.
 bool das_dwrite_append ( void * hh, const void * data, uint64_t bytes ) {
@@ -2839,7 +2934,13 @@ bool das_dwrite_append ( void * hh, const void * data, uint64_t bytes ) {
         // source goes straight to the device, skipping a full memcpy of the payload (~10% of wall
         // time at 2 GB/s). Checked per iteration, not once on entry — a plane rarely starts on a
         // band boundary, but it reaches one after the first partial band and the rest is bulk.
+        // Synchronous by contract (the caller may retire `data` the moment we return), so the
+        // in-flight band must land first to keep the cursor strictly ascending.
         if ( w->fill == 0 && bytes >= w->band_bytes && (uintptr_t(src) % w->align) == 0 ) {
+            if ( !das_dwrite_wait_async(w) ) {
+                w->ok = false;
+                return false;
+            }
             uint64_t direct = (bytes / w->align) * w->align;
             uint64_t t0 = das_dwrite_now_ns();
             bool wok = das_dwrite_raw(w, src, direct);
@@ -2863,14 +2964,10 @@ bool das_dwrite_append ( void * hh, const void * data, uint64_t bytes ) {
         src += take;
         bytes -= take;
         if ( w->fill == w->band_bytes ) {
-            uint64_t t0 = das_dwrite_now_ns();
-            bool wok = das_dwrite_raw(w, w->band, w->band_bytes);
-            w->write_ns += das_dwrite_now_ns() - t0;
-            if ( !wok ) {
+            if ( !das_dwrite_flush_full_band(w) ) {
                 w->ok = false;
                 return false;
             }
-            w->fill = 0;
         }
     }
     return true;
@@ -2884,6 +2981,7 @@ bool das_dwrite_append ( void * hh, const void * data, uint64_t bytes ) {
 uint64_t das_dwrite_stat ( void * hh, int which ) {
     DasDirectWriter * w = (DasDirectWriter *) hh;
     if ( !w ) return 0;
+    std::lock_guard<std::mutex> g(w->mtx);   // write_ns updates on the writer thread
     switch ( which ) {
         case 0: return w->copy_ns;
         case 1: return w->write_ns;
@@ -2909,11 +3007,10 @@ bool das_dwrite_commit ( void * hh, uint64_t bytes ) {
     if ( w->fill + bytes > w->band_bytes ) return false;   // the producer overran its own band
     w->fill += bytes;
     if ( w->fill == w->band_bytes ) {
-        if ( !das_dwrite_raw(w, w->band, w->band_bytes) ) {
+        if ( !das_dwrite_flush_full_band(w) ) {
             w->ok = false;
             return false;
         }
-        w->fill = 0;
     }
     return true;
 }

From 5b25edd47e7ee196960009f7822b3ca75f380510 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 03:09:17 -0700
Subject: [PATCH 16/30] =?UTF-8?q?dlim=20arc=20phase=20G:=20dwrite=20mechan?=
 =?UTF-8?q?ics=20tests=20=E2=80=94=20round-trip,=20truncate=20contract,=20?=
 =?UTF-8?q?band/commit,=20stat=20counters?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

tests/fio/fio_dwrite.das: odd-size appends (sub-sector through multi-band) round-trip
byte-for-byte and close truncates the preallocation to exactly the appended bytes;
the band/commit producer path crosses band boundaries (the async flush + swap point)
intact; append and band/commit interleave in order; bounce/direct stat accounting;
an impossible path declines with null. 5/5, and the suite exercises the new
double-buffered writer thread on every boundary flush.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 tests/fio/fio_dwrite.das | 150 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 150 insertions(+)
 create mode 100644 tests/fio/fio_dwrite.das

diff --git a/tests/fio/fio_dwrite.das b/tests/fio/fio_dwrite.das
new file mode 100644
index 0000000000..c66f29735a
--- /dev/null
+++ b/tests/fio/fio_dwrite.das
@@ -0,0 +1,150 @@
+options gen2
+require dastest/testing_boost
+require daslib/fio
+
+// dwrite is the cache-bypassing sequential appender (bounce bands re-block any caller size to
+// the sector alignment NO_BUFFERING-class paths demand; full bands flush on a writer thread).
+// These are mechanics tests — round-trip content, the append-only + close-truncate contract,
+// the band/commit producer path, stat counters — not timing.
+
+def private dwrite_pattern(i : int) : uint8 => uint8((i * 7 + 13) % 256)
+
+def private make_probe_path(tag : string) : string {
+    var terr : string
+    let tmp = temp_directory(terr)   // portable (no /tmp on Windows); cwd as a last resort
+    return path_join(empty(tmp) ? "." : tmp, "fio_dwrite_{tag}_{ref_time_ticks()}.bin")
+}
+
+def private verify_file_bytes(t : T?; fname : string; total : int; tag : string) {
+    var checked = false
+    fopen(fname, "rb") $(f) {
+        if (f == null) {
+            return
+        }
+        fmap(f) $(var bytes : array<uint8>#) {
+            var intact = long_length(bytes) == int64(total)
+            t |> success(intact, "{tag}: file is exactly the appended size")
+            if (intact) {
+                for (i in range(total)) {
+                    if (bytes[i] != dwrite_pattern(i)) {
+                        intact = false
+                        break
+                    }
+                }
+            }
+            t |> success(intact, "{tag}: content round-trips byte-for-byte")
+            checked = true
+        }
+    }
+    t |> success(checked, "{tag}: mapped the written file back")
+}
+
+[test]
+def test_dwrite(t : T?) {
+    t |> run("odd-size appends round-trip and close truncates the preallocation") @(t : T?) {
+        let fname = make_probe_path("odd")
+        // preallocate far more than we append — close must cut the file back
+        var w = unsafe(dwrite_open(fname, 1048576ul, 8192ul))
+        t |> success(w != null, "writer opened")
+        return if (w == null)
+        // odd sizes on both sides of the band: sub-sector, near-band, multi-band
+        var sizes <- [1, 3, 4095, 8192, 65537, 12345, 100000]
+        var payload : array<uint8>
+        var total = 0
+        var ok = true
+        for (sz in sizes) {
+            payload |> resize(sz)
+            for (i in range(sz)) {
+                payload[i] = dwrite_pattern(total + i)
+            }
+            ok = ok && unsafe(dwrite_append(w, unsafe(addr<void?>(payload[0])), uint64(sz)))
+            total += sz
+        }
+        t |> success(ok, "every append accepted")
+        // bounce accounting: nothing here was band-sized from an aligned source, so every byte
+        // staged through the band and none went direct
+        t |> equal(uint64(total), unsafe(dwrite_stat(w, 3)), "bounce bytes == appended bytes")
+        t |> equal(0ul, unsafe(dwrite_stat(w, 2)), "no direct bytes on sub-band appends")
+        t |> success(unsafe(dwrite_close(w)), "close flushed the tail and truncated")
+        verify_file_bytes(t, fname, total, "odd-size appends")
+        delete payload
+        delete sizes
+        remove(fname)
+    }
+    t |> run("the band/commit producer path crosses band boundaries intact") @(t : T?) {
+        let fname = make_probe_path("band")
+        var w = unsafe(dwrite_open(fname, 0ul, 8192ul))
+        t |> success(w != null, "writer opened")
+        return if (w == null)
+        // build bytes straight into the writer's own staging band, committing uneven runs so
+        // several commits land exactly on a band boundary (the async flush + swap point)
+        var total = 0
+        var ok = true
+        while (total < 50000) {
+            var avail = 0ul
+            var band = unsafe(dwrite_band(w, unsafe(addr(avail))))
+            if (band == null || avail == 0ul) {
+                ok = false
+                break
+            }
+            var take = 3000
+            if (uint64(take) > avail) {
+                take = int(avail)   // top the band off exactly — forces the boundary flush
+            }
+            var bp = unsafe(reinterpret<uint8?>(band))
+            for (i in range(take)) {
+                unsafe {
+                    bp[i] = dwrite_pattern(total + i)
+                }
+            }
+            ok = ok && unsafe(dwrite_commit(w, uint64(take)))
+            total += take
+        }
+        t |> success(ok, "every band commit accepted")
+        t |> success(unsafe(dwrite_close(w)), "close flushed the tail")
+        verify_file_bytes(t, fname, total, "band/commit")
+        remove(fname)
+    }
+    t |> run("append and band/commit interleave in order") @(t : T?) {
+        let fname = make_probe_path("mixed")
+        var w = unsafe(dwrite_open(fname, 0ul, 8192ul))
+        t |> success(w != null, "writer opened")
+        return if (w == null)
+        var payload : array<uint8>
+        var total = 0
+        var ok = true
+        for (round in range(6)) {
+            let sz = 5000 + round * 777
+            payload |> resize(sz)
+            for (i in range(sz)) {
+                payload[i] = dwrite_pattern(total + i)
+            }
+            ok = ok && unsafe(dwrite_append(w, unsafe(addr<void?>(payload[0])), uint64(sz)))
+            total += sz
+            var avail = 0ul
+            var band = unsafe(dwrite_band(w, unsafe(addr(avail))))
+            if (band == null || avail < 100ul) {
+                ok = false
+                break
+            }
+            var bp = unsafe(reinterpret<uint8?>(band))
+            for (i in range(100)) {
+                unsafe {
+                    bp[i] = dwrite_pattern(total + i)
+                }
+            }
+            ok = ok && unsafe(dwrite_commit(w, 100ul))
+            total += 100
+        }
+        t |> success(ok, "interleaved appends and commits accepted")
+        t |> success(unsafe(dwrite_close(w)), "close flushed the tail")
+        verify_file_bytes(t, fname, total, "interleaved")
+        delete payload
+        remove(fname)
+    }
+    t |> run("degenerate opens decline instead of crashing") @(t : T?) {
+        // a directory that cannot exist — open returns null, no throw
+        let w = unsafe(dwrite_open("Z:/no/such/dir/ever/fio_dwrite_probe.bin", 0ul, 0ul))
+        t |> success(w == null, "impossible path declines with null")
+    }
+}

From 2f0efdbc0d31ef443daa8d2f620022730598903c Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 03:16:56 -0700
Subject: [PATCH 17/30] dlim arc phase G: converter --list / --clean (the dlim
 GC) + image_peek + B5 weight-bytes fix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

image_peek reads what tooling needs WITHOUT loading: header fields plus the v7 meta
head's baked identity and embedded config JSON (pre-v7 layouts are unknowable and
report empty). --list inventories every .dlim beside -m (a GGUF or a directory) with
size, version, verdict, identity; verdicts compare against the identities THIS box
would produce now across flavors and quants — CURRENT / OTHER (loadable, possibly
another box's bake) / STALE vN / BROKEN. --clean GCs only what can never load again
(BROKEN + version-stale), never a loadable image; dry-run by default, --apply acts,
and an applied clean also sweeps the stale-tmp siblings.

Live receipt (Qwen3-4B Q4KM, 9 sibling images): 1 CURRENT, 4 OTHER v7 (trimmed
vulkan bakes + portable-backend configs — kept), 4 STALE v6 flagged for --apply.

B5: model_weights_bytes now counts q51q/q51s, mblob, vkblob, and the trim planes
embq/embs — a flavor image no longer reports its bake bytes as 0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/dasllama/dasllama_common.das |  5 +-
 modules/dasLLAMA/dasllama/dasllama_image.das  | 55 +++++++++++
 utils/dasllama-convert/main.das               | 95 +++++++++++++++++++
 3 files changed, 154 insertions(+), 1 deletion(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index cc5c08fc5b..ba65e66f30 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -1141,7 +1141,10 @@ def model_weights_bytes(t : Model) : int64 {
         + long_length(t.mxq) + long_length(t.mxs)
         + long_length(t.bf16blob) * 2l
         + long_length(t.k4q) + long_length(t.k4s) + long_length(t.k5q) + long_length(t.k5s)
-        + long_length(t.k6q) + long_length(t.k6s) + long_length(t.q40q) + long_length(t.q40s))
+        + long_length(t.k6q) + long_length(t.k6s) + long_length(t.q40q) + long_length(t.q40s)
+        + long_length(t.q51q) + long_length(t.q51s)
+        + long_length(t.mblob) + long_length(t.vkblob)
+        + long_length(t.embq) + long_length(t.embs))
 }
 
 // ===== Arch registry: per-architecture blocks + chat template =====
diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index 15c0997b77..e1a6a26445 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -64,6 +64,61 @@ def image_path_for(gguf_path : string; tag : string = ""; quant : string = "q8")
     return "{gguf_path}.{hash(image_identity(tag, quant))}.dlim"
 }
 
+//! What list/GC tooling reads from an image WITHOUT loading it: the header fields plus the
+//! meta head's baked identity and embedded config JSON (empty when the version's layout is
+//! unknown — pre-v7 images carry no readable head).
+struct DlimPeek {
+    valid : bool          //!< magic/page/bounds all sane (any version)
+    version : int
+    bytes : int64
+    identity : string
+    config_json : string
+}
+
+def image_peek(path : string) : DlimPeek {
+    var p = DlimPeek()
+    var msize = 0ul
+    var base : void?
+    unsafe {
+        base = fmap_open(path, addr(msize))
+    }
+    if (base == null || int64(msize) < IMAGE_HEADER_BYTES) {
+        if (base != null) {
+            unsafe(fmap_close(base, msize))
+        }
+        return p
+    }
+    var bp = unsafe(reinterpret<uint8 const?>(base))
+    p.bytes = int64(msize)
+    p.version = int(read_u32(bp, 4l))
+    let meta_off = read_u64(bp, 16l)
+    let meta_bytes = read_u64(bp, 24l)
+    p.valid = (read_u32(bp, 0l) == IMAGE_MAGIC && read_u32(bp, 8l) == uint(IMAGE_PAGE)
+        && read_u64(bp, 32l) == msize && meta_bytes != 0ul && meta_bytes <= msize
+        && meta_off <= msize - meta_bytes && meta_bytes <= uint64(INT_MAX))
+    if (p.valid && p.version >= 7) {
+        var head : array<uint8>
+        head |> resize(int(min(meta_bytes, 65536ul)))
+        unsafe {
+            memcpy(addr(head[0]), reinterpret<void?>(bp + int64(meta_off)), uint64(long_length(head)))
+        }
+        var hmeta <- new MemSerializer(head)
+        var harch = Archive(reading = true, stream = hmeta)
+        harch |> serialize(p.identity)
+        harch |> serialize(p.config_json)
+        if (!hmeta->OK()) {
+            p.identity = ""
+            p.config_json = ""
+        }
+        delete head
+        unsafe {
+            delete hmeta
+        }
+    }
+    unsafe(fmap_close(base, msize))
+    return p
+}
+
 def private pad_to_page(cur : uint64) : uint64 {
     let page = uint64(IMAGE_PAGE)
     return (cur + page - 1ul) / page * page
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index e645c5e7a5..ec34c793af 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -71,6 +71,15 @@ struct ConvertArgs {
     @clarg_doc = "Streaming conversion (planar q8): big planes go source->transcode->image without materializing in RAM; unstreamable models fall back to eager automatically"
     stream : bool
 
+    @clarg_doc = "List every .dlim beside -m (a GGUF, or a directory): size, version, verdict, baked identity"
+    list : bool
+
+    @clarg_doc = "GC beside -m: old-version and unreadable .dlim files (never a loadable image — another box's bake reads as OTHER and stays). DRY-RUN unless --apply"
+    clean : bool
+
+    @clarg_doc = "With --clean: actually delete (the default is a dry-run listing)"
+    apply : bool
+
     @clarg_doc = "Convert even if a valid image is already there (default: report it and exit 0)"
     force : bool
 
@@ -129,6 +138,87 @@ def private quant_from_string(s : string; var q : QuantMode&) : bool {
     return true
 }
 
+// identities this box would produce right now, across flavors and quants — the CURRENT verdict
+def private current_identities : table<string> {
+    var idents : table<string>
+    for (q in ["q8", "fp32", "q4_0"]) {
+        idents |> insert(image_identity("", q))
+        idents |> insert(image_identity(METAL_IMAGE_TAG, q))
+        let vk = moe_gpu_bake_tag()
+        if (vk != "") {
+            idents |> insert(image_identity(vk, q))
+        }
+    }
+    return <- idents
+}
+
+def private image_verdict(p : DlimPeek; current : table<string>) : string {
+    if (!p.valid) {
+        return "BROKEN"
+    }
+    if (p.version != IMAGE_VERSION) {
+        return "STALE v{p.version}"
+    }
+    return key_exists(current, p.identity) ? "CURRENT" : "OTHER"
+}
+
+// list = the inventory; clean = GC of what can never load again (BROKEN + version-stale).
+// A loadable image is NEVER removed: OTHER may be another box's bake carried here on purpose.
+def private list_images(cfg : ConvertArgs) : int {
+    var st : FStat
+    if (!stat(cfg.model, st)) {
+        to_log(LOG_ERROR, "dasllama-convert: no such path '{cfg.model}'\n")
+        return 2
+    }
+    let dirp = st.is_dir ? cfg.model : dir_name(cfg.model)
+    let base = st.is_dir ? "" : base_name(cfg.model)
+    var current <- current_identities()
+    var n = 0
+    var stale = 0
+    var removed = 0
+    var freed = 0l
+    dir(dirp) $(name : string) {
+        if (!(name |> ends_with(".dlim")) || (base != "" && !(name |> starts_with(base)))) {
+            return
+        }
+        let full = path_join(dirp, name)
+        let p = image_peek(full)
+        let verdict = image_verdict(p, current)
+        n++
+        if (!cfg.clean) {
+            let idnote = empty(p.identity) ? "" : "  {p.identity}"
+            to_log(LOG_INFO, "dasllama-convert: {name}\n")
+            to_log(LOG_INFO, "dasllama-convert:   {p.bytes >> 20l} MB  v{p.version}  {verdict}{idnote}\n")
+            return
+        }
+        return if (p.valid && p.version == IMAGE_VERSION)   // CURRENT or OTHER: loadable — stays
+        stale++
+        if (!cfg.apply) {
+            to_log(LOG_INFO, "dasllama-convert: would remove {name} ({p.bytes >> 20l} MB, {verdict})\n")
+            return
+        }
+        if (remove(full)) {
+            removed++
+            freed += p.bytes
+            to_log(LOG_INFO, "dasllama-convert: removed {name} ({p.bytes >> 20l} MB, {verdict})\n")
+        } else {
+            to_log(LOG_WARNING, "dasllama-convert: could not remove {name} — in use?\n")
+        }
+    }
+    if (!cfg.clean) {
+        to_log(LOG_INFO, "dasllama-convert: {n} image(s)\n")
+    } elif (cfg.apply) {
+        to_log(LOG_INFO, "dasllama-convert: removed {removed} of {stale} stale image(s), reclaimed {freed >> 20l} MB\n")
+    } else {
+        to_log(LOG_INFO, "dasllama-convert: {stale} stale of {n} image(s) — rerun with --apply to remove\n")
+    }
+    if (cfg.clean && cfg.apply && !st.is_dir) {
+        sweep_stale_tmp(cfg.model)
+    }
+    delete current
+    return 0
+}
+
 def private flavor_tag(f : Flavor) : string {
     if (f == Flavor.metal) {
         return METAL_IMAGE_TAG
@@ -187,6 +277,11 @@ def main() : int {
         print_help(get_command_info(type<ConvertArgs>), "dasllama-convert")
         return 2
     }
+    if (cfg.list || cfg.clean) {
+        // verdicts compare against this box's CURRENT identities — same pin the load path takes
+        apply_box_profile_runtime()
+        return list_images(cfg)
+    }
     if (!stat(cfg.model).is_valid) {
         to_log(LOG_ERROR, "dasllama-convert: no such GGUF '{cfg.model}'\n")
         return 2

From c96e8f1d522e4796b9c547b8d8e0ef14fcb6b317 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 03:23:49 -0700
Subject: [PATCH 18/30] dlim arc phase G: image-mechanics arms for the v7 meta
 head and config round-trip

The mechanics suite (CI-safe, no models) grows: image_peek on the synthetic carrier
reads version + baked identity + embedded config without loading, and the embedded
config re-derives the exact identity the image was saved under; DlimConfiguration
JSON round-trips with the identity intact, garbage declines.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/tests/test_model_image.das | 24 +++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/modules/dasLLAMA/tests/test_model_image.das b/modules/dasLLAMA/tests/test_model_image.das
index 632d6c7bdd..2c764ea607 100644
--- a/modules/dasLLAMA/tests/test_model_image.das
+++ b/modules/dasLLAMA/tests/test_model_image.das
@@ -7,6 +7,7 @@ require dasllama/dasllama            // the facade: load_model's image cache is
 require dasllama/dasllama_whisper
 require dasllama/dasllama_gguf       // rd_u32/rd_u16 — the wav fixture reader
 require dasllama/dasllama_image
+require dasllama/dasllama_config     // DlimConfiguration — the peek/round-trip mechanics arms
 require dasllama/dasllama_math   // pin_kernel_backend — the metal-flavor arm's donor contract
 require daslib/jobque_boost
 require daslib/archive
@@ -214,6 +215,16 @@ def test_image_mechanics(t : T?) {
         t |> success(load_image(path, m2b, "img-probe"), "re-saved image maps")
         delete m2b
 
+        // the v7 meta head: peek reads version + identity + embedded config WITHOUT loading,
+        // and the embedded config re-derives the exact identity the image was baked under
+        let pk = image_peek(path)
+        t |> success(pk.valid, "peek: header sane")
+        t |> equal(pk.version, IMAGE_VERSION, "peek: version")
+        t |> equal(pk.identity, image_identity("img-probe"), "peek: baked identity string")
+        var pcfg = DlimConfiguration()
+        t |> success(dlim_config_from_json(pk.config_json, pcfg), "peek: embedded config JSON parses")
+        t |> equal(dlim_identity(pcfg, IMAGE_VERSION, "img-probe"), pk.identity, "peek: config re-derives the identity")
+
         var m3 = ImgProbe()
         t |> success(!load_image(path, m3, "wrong-tag"), "identity mismatch declines")
         patch_u32(t, path, 4l, 0xDEADu)
@@ -262,6 +273,19 @@ def test_image_mechanics(t : T?) {
         t |> success(caught, "forget on an owned locked array is a loud error")
         delete owned
     }
+    t |> run("DlimConfiguration JSON round-trips with the identity intact") @(t : T?) {
+        if (!arm_on(t, "mechanics")) {
+            return
+        }
+        let dc = dlim_config_current("q8")
+        let js = dlim_config_json(dc)
+        t |> success(!empty(js), "config serializes")
+        var back = DlimConfiguration()
+        t |> success(dlim_config_from_json(js, back), "JSON parses back")
+        t |> equal(dlim_identity(back, IMAGE_VERSION), dlim_identity(dc, IMAGE_VERSION), "identity survives the round trip")
+        var junk = DlimConfiguration()
+        t |> success(!dlim_config_from_json("not a config", junk), "garbage declines")
+    }
 }
 
 // ===== real carriers: gguf load vs mapped image load =====

From 9b16ccc0d897b725741cc8c1502b6eb053f5ff50 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 06:18:01 -0700
Subject: [PATCH 19/30] =?UTF-8?q?fio:=20fmap=5Fopen=5Frw=20=E2=80=94=20a?=
 =?UTF-8?q?=20writable=20SHARED=20file=20mapping;=20closes=20the=20import?=
 =?UTF-8?q?=202x2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The win32 mmap shim now honors PROT_WRITE (PAGE_READWRITE / FILE_MAP_WRITE — a real
shared writable view, writes go back to the file, still no commit charge), and
fmap_open_rw is the writable twin of fmap_open on both platforms. Same ownership
contract; fmap_close unmaps either kind. Tests are a flagged follow-up.

The consumer that motivated it: VK_EXT_external_memory_host imports. The probe 2x2
(_vk_import_probe.das) is now closed on NVIDIA/Windows: anonymous writable memory
imports fine, file-backed memory is refused with ERROR_OUT_OF_DEVICE_MEMORY in BOTH
protections — the blocker is the file backing, not the page protection. So the
imported-mirror rail cannot engage on this driver under any mapping mode, and the
pinned-copy fallback stands; the rail self-enables on drivers that accept
file-backed host pointers. make_imported_buf's comment records the proven rule.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 include/daScript/simulate/aot_builtin_fio.h   |  1 +
 .../dasllama/dasllama_math_vulkan.das         |  4 +-
 src/builtin/module_builtin_fio.cpp            | 42 +++++++++++++++++--
 3 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/include/daScript/simulate/aot_builtin_fio.h b/include/daScript/simulate/aot_builtin_fio.h
index 17208e36e1..ab02b090e2 100644
--- a/include/daScript/simulate/aot_builtin_fio.h
+++ b/include/daScript/simulate/aot_builtin_fio.h
@@ -88,6 +88,7 @@ namespace das {
     DAS_API vec4f builtin_load ( Context & context, SimNode_CallBase *, vec4f * args );
     DAS_API void builtin_map_file ( const FILE* _f, const TBlock<void, TTemporary<TArray<uint8_t>>>& blk, Context*, LineInfoArg * at );
     DAS_API void * builtin_fmap_open ( const char * name, uint64_t * size, Context * context, LineInfoArg * at );
+    DAS_API void * builtin_fmap_open_rw ( const char * name, uint64_t * size, Context * context, LineInfoArg * at );
     DAS_API void builtin_fmap_close ( void * data, uint64_t size, Context * context, LineInfoArg * at );
     DAS_API void * builtin_dwrite_open ( const char * name, uint64_t total_bytes, uint64_t band_bytes, Context * context, LineInfoArg * at );
     DAS_API bool builtin_dwrite_append ( void * h, void * data, uint64_t bytes, Context * context, LineInfoArg * at );
diff --git a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
index 4760dad429..84eaa8cf4c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_vulkan.das
@@ -4807,8 +4807,8 @@ def private vk_import_declined(why : string) {
 }
 
 // P2: import a 4KB-aligned mapped-file window as a transfer_src buffer (VK_EXT_external_memory_host).
-// buf == 0 = declined, the caller falls back to the pinned copy — NVIDIA/Windows refuses READ-ONLY
-// file-backed pages (anon writable imports succeed; probe-verified 2026-07-28, _vk_import_probe.das)
+// buf == 0 = declined, the caller falls back to the pinned copy. NVIDIA/Windows refuses FILE-BACKED
+// pages in BOTH protections while anon imports succeed (full 2x2: _vk_import_probe.das, 2026-07-28)
 def private make_imported_buf(ptr : void?; bytes : int64) : HostBuf {
     let hb = HostBuf()
     if (ptr == null || bytes <= 0l || !device_extension_available(g_gpu.phys, "VK_EXT_external_memory_host")) {
diff --git a/src/builtin/module_builtin_fio.cpp b/src/builtin/module_builtin_fio.cpp
index e587649314..69e6eb562c 100644
--- a/src/builtin/module_builtin_fio.cpp
+++ b/src/builtin/module_builtin_fio.cpp
@@ -185,6 +185,7 @@ namespace das {
     void builtin_fflush ( const FILE * f, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     void builtin_map_file(const FILE* f, const TBlock<void, TTemporary<TArray<uint8_t>>>& blk, Context* context, LineInfoArg * at) GENERATE_IO_STUB
     void * builtin_fmap_open ( const char * name, uint64_t * size, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    void * builtin_fmap_open_rw ( const char * name, uint64_t * size, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     void builtin_fmap_close ( void * data, uint64_t size, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     int64_t builtin_ftell ( const FILE * f, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     int64_t builtin_fseek ( const FILE * f, int64_t offset, int32_t mode, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
@@ -455,6 +456,33 @@ namespace das {
         return data;
     }
 
+    // the writable twin: a PAGE_READWRITE / PROT_WRITE SHARED mapping — writes go back to the
+    // file through the page cache; still no commit charge (not WRITECOPY). The consumer that
+    // wanted it: device APIs that refuse to import read-only pages (VK_EXT_external_memory_host
+    // on NVIDIA/Windows). Same ownership contract as fmap_open; fmap_close unmaps either kind.
+    void * builtin_fmap_open_rw ( const char * name, uint64_t * size, Context * context, LineInfoArg * at ) {
+        if ( !size ) context->throw_error_at(at, "fmap_open_rw: null size out-param");
+        *size = 0;
+        if ( !name ) context->throw_error_at(at, "fmap_open_rw: null path");
+        FILE * f = das_fopen_utf8(name, "r+b");   // the writable section needs write on the handle
+        if ( !f ) return nullptr;
+        das_filestat st;
+        int fd = fileno(f);
+        if ( das_fstat64(fd, st) != 0 ) {
+            fclose(f);
+            return nullptr;
+        }
+        if ( st.st_size == 0 || uint64_t(st.st_size) != uint64_t(size_t(st.st_size)) ) {
+            fclose(f);
+            return nullptr;
+        }
+        void * data = mmap(nullptr, size_t(st.st_size), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        fclose(f);
+        if ( data == MAP_FAILED ) return nullptr;
+        *size = uint64_t(st.st_size);
+        return data;
+    }
+
     void builtin_fmap_close ( void * data, uint64_t size, Context * context, LineInfoArg * at ) {
         if ( !data ) context->throw_error_at(at, "fmap_close: null mapping");
         munmap(data, size_t(size));
@@ -2311,6 +2339,9 @@ namespace das {
             addExtern<DAS_BIND_FUN(builtin_fmap_open)>(*this, lib, "fmap_open",
                 SideEffects::modifyExternal, "builtin_fmap_open")
                     ->args({"path","size","context","line"})->unsafeOperation = true;
+            addExtern<DAS_BIND_FUN(builtin_fmap_open_rw)>(*this, lib, "fmap_open_rw",
+                SideEffects::modifyExternal, "builtin_fmap_open_rw")
+                    ->args({"path","size","context","line"})->unsafeOperation = true;
             addExtern<DAS_BIND_FUN(builtin_fmap_close)>(*this, lib, "fmap_close",
                 SideEffects::modifyExternal, "builtin_fmap_close")
                     ->args({"data","size","context","line"})->unsafeOperation = true;
@@ -2552,7 +2583,7 @@ namespace das {
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
-void * mmap (void* start, size_t length, int /*prot*/, int /*flags*/, int fd, off_t offset) {
+void * mmap (void* start, size_t length, int prot, int /*flags*/, int fd, off_t offset) {
     HANDLE hmap;
     void* temp;
     size_t len;
@@ -2570,11 +2601,14 @@ void * mmap (void* start, size_t length, int /*prot*/, int /*flags*/, int fd, of
     // a 73 GB gguf mapping showed up as 73 GB of private bytes on top of the model itself
     // (measured 2026-07-27: 149.9 GB private for a 78 GB image). Read-only maps charge nothing,
     // match what POSIX already does here (PROT_READ), and fault loudly on an accidental write
-    // instead of silently privatizing the page.
-    hmap = CreateFileMapping((HANDLE)_get_osfhandle(fd), 0, PAGE_READONLY, 0, 0, 0);
+    // instead of silently privatizing the page. PROT_WRITE = a real shared writable view
+    // (PAGE_READWRITE, writes go back to the file) — the fmap_open_rw path; still no commit charge.
+    DWORD page = (prot & PROT_WRITE) ? PAGE_READWRITE : PAGE_READONLY;
+    DWORD access = (prot & PROT_WRITE) ? (FILE_MAP_READ | FILE_MAP_WRITE) : FILE_MAP_READ;
+    hmap = CreateFileMapping((HANDLE)_get_osfhandle(fd), 0, page, 0, 0, 0);
     if (!hmap)
         return MAP_FAILED;
-    temp = MapViewOfFileEx(hmap, FILE_MAP_READ, h, l, length, start);
+    temp = MapViewOfFileEx(hmap, access, h, l, length, start);
     if (!CloseHandle(hmap))
         fprintf(stderr, "unable to close file mapping handle\n");
     return temp ? temp : MAP_FAILED;

From d069e6e2545a82ddf3a29f464ea11dcef4b4990d Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 08:43:26 -0700
Subject: [PATCH 20/30] dlim streaming fix: size and gap-fill streamed q-planes
 from the LAYOUT, not the job sum
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The GLM judged A/B caught a phase-D correctness bug the 4B gates could not see: a
plane layout can hold allocated-but-never-written holes — glm4moe's dense-lead
layer gets shexp slices in the wsh spans (layout_offsets allocates all 47 layers)
but has no shexp tensors on disk, so no FillJob covers them. The streamed fill
concatenated jobs, so everything past the first hole landed SHIFTED and the qblob
section came up 17,301,504 bytes short (3 planes x one 4096x1408 slice) — a
corrupt image that its own header could not detect.

Fix: the sizing pass records each streamed q-plane's LAYOUT byte total
(g_stream_plane_total); stream_plane_bytes serves that total; fill_stream_plane
tracks a byte cursor and zero-fills the gaps between jobs and the tail — exactly
the zeros the eager path writes from its zero-initialized RAM planes.

Gates: GLM streamed vs eager now cmp-IDENTICAL across the whole 82.4 GB file
(peak 16.34 GB held); 4B Q4KM/Q8_0 streamed SHAs unchanged (2323ebec…, 96b97b33…).
Judged GLM receipts (quiet box): streamed 739 s / 16.36 GB peak vs eager 880 s /
81.87 GB peak — the writer split shows 99.9% of the eager save inside write
syscalls, so conversion is device-bound at the drive's sustained rate and
streaming wins both axes. (Rates degraded 112 -> 98 -> 73 MB/s across the three
consecutive 78 GB writes — SLC-cache exhaustion; cross-run rate comparisons are
drive-state-confounded, the byte parity is not.)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/dasllama/dasllama_common.das | 60 ++++++++++++++++++-
 1 file changed, 59 insertions(+), 1 deletion(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index ba65e66f30..d39065154c 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -1762,6 +1762,10 @@ def register_stream_layout(cq8, ckq, cq51 : StreamCollectFn; rr : StreamRepackFn
 
 var private g_fill_plan_mode = false
 var private g_fill_plan : array<FillJob>
+// field -> the plane's LAYOUT byte total, recorded at sizing: a layout can hold allocated-but-
+// never-written holes (glm4moe's dense-lead shexp slices), so the streamed plane must be sized
+// and gap-filled from the layout — a job-sum concatenation SHIFTS everything past the first hole
+var private g_stream_plane_total : table<string; int64>
 
 //! The regions the eager repack stage WOULD build for `t` — same gates, same walkers (the
 //! collector halves), so the streamed fill's per-job repack cannot drift from the eager one.
@@ -1813,8 +1817,29 @@ def private stream_job_shape(t : Model; j : FillJob) : tuple<qb : int64; sb : in
     return (qb = j.n, sb = 0l, rfmt = 0)   // q8: 1 byte/elem quants; scales handled as floats
 }
 
-//! Total bytes the streamed fill will append for `field` (page padding NOT included).
+// a job's byte offset within its plane (woff is elems; kq/q51 planes stride per superblock)
+def private stream_job_qoff(j : FillJob) : int64 {
+    if (j.fmt == KqFmt.k4) {
+        return (j.woff / 256l) * K4_QSB
+    } elif (j.fmt == KqFmt.k5) {
+        return (j.woff / 256l) * K5_QSB
+    } elif (j.fmt == KqFmt.k6) {
+        return (j.woff / 256l) * K6_QSB
+    } elif (j.fmt == KqFmt.q40) {
+        return (j.woff / 256l) * Q40_QSB
+    } elif (j.fmt == KqFmt.q51) {
+        return (j.woff / 32l) * Q51_QB
+    }
+    return j.woff
+}
+
+//! Total bytes the streamed fill will append for `field` (page padding NOT included) — the
+//! LAYOUT size when the sizing pass recorded one (holes included), else the job sum.
 def stream_plane_bytes(t : Model; jobs : array<FillJob>; field : string) : int64 {
+    let lt = g_stream_plane_total?[field] ?? 0l
+    if (lt > 0l) {
+        return lt
+    }
     var total = 0l
     for (j in jobs) {
         if (stream_field_of(t, j.fmt) == field) {
@@ -1824,6 +1849,22 @@ def stream_plane_bytes(t : Model; jobs : array<FillJob>; field : string) : int64
     return total
 }
 
+// append `gap` zero bytes — a layout hole the jobs never cover (never-written plane space)
+def private stream_zero_fill(gap : int64; var zeros : array<uint8>;
+                             append : block<(p : void?; nbytes : uint64) : void>) {
+    var left = gap
+    if (left > 0l && empty(zeros)) {
+        zeros |> resize(1048576)
+    }
+    while (left > 0l) {
+        let chunk = min(left, long_length(zeros))
+        unsafe {
+            invoke(append, addr<void?>(zeros[0]), uint64(chunk))
+        }
+        left -= chunk
+    }
+}
+
 //! Execute every recorded job targeting `field`: transcode into a job-sized temp (load_big's
 //! own arms at temp offset 0), land scales in the RAM plane, apply the job's repack regions
 //! (temp-biased q, in-place s), hand the temp to `append`; qblob's tail runs the wscale epilogue.
@@ -1846,8 +1887,12 @@ def fill_stream_plane(m : GGUFMeta; bytes : array<uint8> | #; var t : Model; fie
     var temp_s : array<uint8>
     var temp_sf : array<float>
     var scratch : array<float>
+    var zeros : array<uint8>
+    var cursor = 0l   // plane bytes appended so far — layout holes between jobs zero-fill
     for (j in mine) {
         let sh = stream_job_shape(t, j)
+        stream_zero_fill(stream_job_qoff(j) - cursor, zeros, append)
+        cursor = stream_job_qoff(j) + sh.qb
         temp_q |> resize(int(sh.qb))
         let t0 = g_conv_prof ? ref_time_ticks() : 0l
         var kind = "q8 transcode (Q8_0 verbatim)"
@@ -1948,6 +1993,8 @@ def fill_stream_plane(m : GGUFMeta; bytes : array<uint8> | #; var t : Model; fie
             }
         }
     }
+    // the layout's tail past the last job (never-written space) completes the plane
+    stream_zero_fill(stream_plane_bytes(t, jobs, field) - cursor, zeros, append)
     if (field == "qblob" && g_wscale_f16) {
         // the epilogue: scales are complete and repacked; qscales16 lands BEFORE its field
         // writes (qblob precedes qscales/qscales16 in Model field order)
@@ -1959,6 +2006,7 @@ def fill_stream_plane(m : GGUFMeta; bytes : array<uint8> | #; var t : Model; fie
     delete temp_s
     delete temp_sf
     delete scratch
+    delete zeros
     return true
 }
 
@@ -4266,6 +4314,16 @@ def private load_gguf_parsed(var t : Model; m : GGUFMeta; bytes : array<uint8> |
         // streaming: big q-halves never materialize (jobs stream them to the writer); scale
         // halves are small (6-16%) and stay in RAM. Unstreamable features disarmed above.
         let stream_q = g_fill_plan_mode
+        if (stream_q) {
+            // the streamed save sizes each q-plane from the LAYOUT (holes included), not the job sum
+            g_stream_plane_total |> clear()
+            g_stream_plane_total["k4q"] = (sz.k4_n / 256l) * K4_QSB
+            g_stream_plane_total["k5q"] = (sz.k5_n / 256l) * K5_QSB
+            g_stream_plane_total["k6q"] = (sz.k6_n / 256l) * K6_QSB
+            g_stream_plane_total["q40q"] = (sz.q40_n / 256l) * Q40_QSB
+            g_stream_plane_total["q51q"] = (sz.q51_n / 32l) * Q51_QB
+            g_stream_plane_total["qblob"] = mode == QuantMode.q8 ? sz.wblob_n : 0l
+        }
         if (sz.k4_n > 0l) {
             if (!stream_q) {
                 t.k4q |> reserve((sz.k4_n / 256l) * K4_QSB)

From f5c6082defc400a63b90921d5eb399dafa585c44 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 09:03:17 -0700
Subject: [PATCH 21/30] fio: fmap_open_rw tests + handmade RST (the flagged
 follow-up)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

tests/fio/fio_fmap_rw.das: writes through the mapping persist to the file after
unmap (verified via a read-only remap), mapped content matches the write, and the
decline shapes (missing file, empty file) return null. 3/3. The handmade RST fills
the das2rst stub — the symbol rides the File manipulation group beside fmap_open;
doc/source/stdlib/generated is CI-regenerated and stays untracked.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 ...on-fio-fmap_open_rw-0x2abb9e9d0dfc252e.rst |   1 +
 tests/fio/fio_fmap_rw.das                     | 102 ++++++++++++++++++
 2 files changed, 103 insertions(+)
 create mode 100644 doc/source/stdlib/handmade/function-fio-fmap_open_rw-0x2abb9e9d0dfc252e.rst
 create mode 100644 tests/fio/fio_fmap_rw.das

diff --git a/doc/source/stdlib/handmade/function-fio-fmap_open_rw-0x2abb9e9d0dfc252e.rst b/doc/source/stdlib/handmade/function-fio-fmap_open_rw-0x2abb9e9d0dfc252e.rst
new file mode 100644
index 0000000000..63a30009cc
--- /dev/null
+++ b/doc/source/stdlib/handmade/function-fio-fmap_open_rw-0x2abb9e9d0dfc252e.rst
@@ -0,0 +1 @@
+The writable twin of ``fmap_open``: memory-maps the file at ``path`` as a SHARED read-write view and returns the mapping's base pointer, writing the mapped byte count through ``size``. Writes through the mapping go back to the file itself via the page cache — this is a real shared mapping, not copy-on-write, so no commit charge is taken for the view. The mapping stays valid until passed to ``fmap_close``. Returns null when the file cannot be opened for writing, is empty, or cannot be mapped.
diff --git a/tests/fio/fio_fmap_rw.das b/tests/fio/fio_fmap_rw.das
new file mode 100644
index 0000000000..25a3d2a828
--- /dev/null
+++ b/tests/fio/fio_fmap_rw.das
@@ -0,0 +1,102 @@
+options gen2
+require dastest/testing_boost
+require daslib/fio
+
+// fmap_open_rw is the writable SHARED twin of fmap_open (PAGE_READWRITE / PROT_WRITE): writes
+// through the mapping go back to the file via the page cache. Contract tests — write-through
+// persistence, read parity with the read-only twin, decline shapes.
+
+def private rw_pattern(i : int) : uint8 => uint8((i * 11 + 5) % 256)
+
+[test]
+def test_fmap_rw(t : T?) {
+    t |> run("writes through the mapping persist to the file") @(t : T?) {
+        var terr : string
+        let tmp = temp_directory(terr)   // portable (no /tmp on Windows); cwd as a last resort
+        let fname = path_join(empty(tmp) ? "." : tmp, "fio_fmap_rw_{ref_time_ticks()}.bin")
+        let n = 65536
+        var payload : array<uint8>
+        payload |> resize(n)
+        for (i in range(n)) {
+            payload[i] = rw_pattern(i)
+        }
+        var wrote = false
+        fopen(fname, "wb") $(f) {
+            if (f != null) {
+                fwrite(f, payload)
+                wrote = true
+            }
+        }
+        t |> success(wrote, "wrote the probe file")
+        // map writable: verify content, then flip a sparse set of bytes through the mapping
+        var msize = 0ul
+        var base : void?
+        unsafe {
+            base = fmap_open_rw(fname, addr(msize))
+        }
+        t |> success(base != null, "fmap_open_rw maps")
+        return if (base == null)
+        t |> equal(uint64(n), msize, "mapped size is the file size")
+        var bp = unsafe(reinterpret<uint8?>(base))
+        var intact = true
+        for (i in range(n)) {
+            if (unsafe(bp[i]) != rw_pattern(i)) {
+                intact = false
+                break
+            }
+        }
+        t |> success(intact, "mapped content matches what was written")
+        var at = 0
+        while (at < n) {
+            unsafe {
+                bp[at] = uint8(255 - int(rw_pattern(at)))
+            }
+            at += 4099
+        }
+        unsafe {
+            fmap_close(base, msize)
+        }
+        // reopen READ-ONLY: the flips must have landed in the file itself
+        var persisted = false
+        fopen(fname, "rb") $(f) {
+            if (f == null) {
+                return
+            }
+            fmap(f) $(var bytes : array<uint8>#) {
+                var ok = long_length(bytes) == int64(n)
+                if (ok) {
+                    for (i in range(n)) {
+                        let want = i % 4099 == 0 ? uint8(255 - int(rw_pattern(i))) : rw_pattern(i)
+                        if (bytes[i] != want) {
+                            ok = false
+                            break
+                        }
+                    }
+                }
+                persisted = ok
+            }
+        }
+        t |> success(persisted, "writes persisted to the file after unmap")
+        delete payload
+        remove(fname)
+    }
+    t |> run("decline shapes: missing and empty files map as null") @(t : T?) {
+        var msize = 1ul
+        var base : void?
+        unsafe {
+            base = fmap_open_rw("no_such_fio_fmap_rw_probe.bin", addr(msize))
+        }
+        t |> success(base == null && msize == 0ul, "missing file declines with null, size 0")
+        var terr : string
+        let tmp = temp_directory(terr)
+        let fname = path_join(empty(tmp) ? "." : tmp, "fio_fmap_rw_empty_{ref_time_ticks()}.bin")
+        fopen(fname, "wb") $(f) {
+            feint("{f != null}")   // an empty file: created, nothing written
+        }
+        unsafe {
+            base = fmap_open_rw(fname, addr(msize))
+        }
+        t |> success(base == null, "empty file declines with null (mmap(0) is invalid)")
+        remove(fname)
+    }
+}

From c6d4a518df66ce42bfa704a906a2e536837d2c4d Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 09:16:49 -0700
Subject: [PATCH 22/30] =?UTF-8?q?dlim=20arc=20phase=20G:=20image-vulkan=20?=
 =?UTF-8?q?suite=20=E2=80=94=20the=20offline=20dry=20bake=20gets=20regress?=
 =?UTF-8?q?ion=20coverage?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

test_model_image_vulkan.das (run.das --suite image-vulkan, arm `vulkan`): the runner
arms DASLLAMA_GPU + a 2000 MB budget so the probed config carries a vulkan section,
the DRY tier collects the bake with zero device calls (safe on GPU-less boxes), and
the test asserts a non-empty role-stamped plan whose planes sit inside the blob,
then saves the flavor image under the tier's bake tag and maps it back with the
plan and blob intact. The offline vulkan bake previously had zero automated
coverage — only the manual parity probe. run.das grows the per-suite env hook.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/tests/CLAUDE.md              |  4 +
 modules/dasLLAMA/tests/run.das                | 10 ++-
 .../tests/test_model_image_vulkan.das         | 77 +++++++++++++++++++
 3 files changed, 90 insertions(+), 1 deletion(-)
 create mode 100644 modules/dasLLAMA/tests/test_model_image_vulkan.das

diff --git a/modules/dasLLAMA/tests/CLAUDE.md b/modules/dasLLAMA/tests/CLAUDE.md
index b051f7af42..e085ec393a 100644
--- a/modules/dasLLAMA/tests/CLAUDE.md
+++ b/modules/dasLLAMA/tests/CLAUDE.md
@@ -62,6 +62,10 @@ carrier, model-free, runs in CI) `smol metal tower whisper voxtral`; the voxtral
 arm mints/maps the blob-only metal flavor (SmolLM2) incl. the CPU-tripwire and a
 teacher-forced logits-tolerance parity cell (greedy token equality is NOT a valid bar on a
 135M — genuine near-ties flip on ~0.02 gaps under ~0.75 cross-backend noise).
+The `image-vulkan` suite (test_model_image_vulkan, arm `vulkan`) covers the OFFLINE vulkan
+bake: the runner arms DASLLAMA_GPU + a small VRAM budget so the probed config carries a
+vulkan section, the DRY tier collects a role-stamped plan with no device calls (safe on
+GPU-less boxes), and the flavor image round-trips the plan verbatim.
 
 ## Blob-only Metal fixtures (the two-model pattern)
 
diff --git a/modules/dasLLAMA/tests/run.das b/modules/dasLLAMA/tests/run.das
index d34741065b..593e3c6106 100644
--- a/modules/dasLLAMA/tests/run.das
+++ b/modules/dasLLAMA/tests/run.das
@@ -54,6 +54,8 @@ def private suite_files(name : string) : array<string> {
         return <- [ "modules/dasLLAMA/tests/test_metal_prefill_kernels.das" ]
     } elif (name == "image") {
         return <- [ "modules/dasLLAMA/tests/test_model_image.das" ]
+    } elif (name == "image-vulkan") {
+        return <- [ "modules/dasLLAMA/tests/test_model_image_vulkan.das" ]
     } elif (name == "all") {
         return <- [ "modules/dasLLAMA/tests/test_metal_decode_parity.das",
                     "modules/dasLLAMA/tests/test_metal_prefill_parity.das",
@@ -114,7 +116,7 @@ def main() : int {
     }
     var files <- suite_files(cfg.suite)
     if (empty(files)) {
-        to_log(LOG_ERROR, "unknown --suite '{cfg.suite}' (decode | prefill | matrix | kernels | image | all)\n")
+        to_log(LOG_ERROR, "unknown --suite '{cfg.suite}' (decode | prefill | matrix | kernels | image | image-vulkan | all)\n")
         return 2
     }
     var tmp = get_env_variable("TMPDIR")
@@ -142,6 +144,12 @@ def main() : int {
             envs = "DASLLAMA_TEST_FAMILY='{cfg.family}' {envs}"
         }
     }
+    if (cfg.suite == "image-vulkan") {
+        // the offline-bake suite: arm the tier so the probed config carries a vulkan section —
+        // the bake itself is DRY (no device calls), so this is safe on GPU-less boxes too
+        envs = (win ? "{envs}set \"DASLLAMA_GPU=1\"&& set \"DASLLAMA_GPU_VRAM_MB=2000\"&& "
+            : "DASLLAMA_GPU=1 DASLLAMA_GPU_VRAM_MB=2000 {envs}")
+    }
     // the full gate holds the 8B/70B tails — the stock 1200s dastest wall is an arm-mode budget
     let tmo = cfg.full ? 3600 : 1200
     let reps = max(cfg.nreps, 1)
diff --git a/modules/dasLLAMA/tests/test_model_image_vulkan.das b/modules/dasLLAMA/tests/test_model_image_vulkan.das
new file mode 100644
index 0000000000..21a6ab6e47
--- /dev/null
+++ b/modules/dasLLAMA/tests/test_model_image_vulkan.das
@@ -0,0 +1,77 @@
+options gen2
+options persistent_heap
+options stack = 131072
+
+require dastest/testing_boost public
+require dasllama/dasllama   // nolint:STYLE029 — umbrella fires each arch [init] registration
+require dasllama/dasllama_image
+require dasllama/dasllama_config
+require dasllama/dasllama_math
+require daslib/jobque_boost
+require daslib/fio
+require _model_tier
+
+// The OFFLINE vulkan bake (plan-as-data): the dry tier runs the load walk's accept/refuse
+// arithmetic against the config's numbers with NO device — the converter's `-f vulkan` rail.
+// Drive through run.das --suite image-vulkan (it arms DASLLAMA_GPU + a small VRAM budget);
+// unarmed contexts skip cleanly, so the file is safe in any suite.
+
+[test]
+def test_vulkan_dry_bake(tst : T?) {
+    tst |> run("SmolLM2 q8: dry bake collects a role-stamped plan and the image round-trips") @(t : T?) {
+        static_if (typeinfo builtin_module_exists(vulkan)) {
+            if (!family_on(t, "llama")) return
+            if (!arm_on(t, "vulkan")) {
+                return
+            }
+            if (!jit_enabled()) {
+                t |> skip("interpreted (dasLLAMA model tests are JIT-only)")
+                return
+            }
+            let path = path_join(models_dir(), "SmolLM2-135M-Instruct-Q8_0.gguf")
+            if (!model_available(t, path)) {
+                return
+            }
+            // the converter's probed-config path: needs the tier armed (run.das --suite image-vulkan)
+            apply_box_profile_runtime()
+            let probed = dlim_config_current("q8")
+            if (!probed.vulkan_on) {
+                t |> skip("vulkan tier not armed (DASLLAMA_GPU) — run via run.das --suite image-vulkan")
+                return
+            }
+            if (!moe_gpu_dry_bake_arm(probed.vulkan)) {
+                t |> skip("dry bake declined to arm — see the log")
+                return
+            }
+            vulkan_bake_begin()
+            var m <- load_model_(path, QuantMode.q8)
+            t |> success(vulkan_bake_take(m), "the dry walk collected a bake")
+            t |> success(long_length(m.vkplan) > 0l, "plan has entries ({long_length(m.vkplan)})")
+            t |> success(long_length(m.vkblob) > 0l, "blob has bytes ({long_length(m.vkblob)})")
+            // every entry is role-stamped and points inside the blob
+            var roles_ok = true
+            var bounds_ok = true
+            for (e in m.vkplan) {
+                roles_ok = roles_ok && e.role != int(VkBakeRole.none)
+                bounds_ok = (bounds_ok && e.wq_off + e.wq_bytes <= long_length(m.vkblob)
+                    && e.ws_off + e.ws_bytes <= long_length(m.vkblob))
+            }
+            t |> success(roles_ok, "every plan entry carries a stage role")
+            t |> success(bounds_ok, "every plan entry's planes sit inside the blob")
+            // the flavor image round-trips the plan verbatim
+            var terr : string
+            let tmp = temp_directory(terr)
+            let img = path_join(empty(tmp) ? "." : tmp, "dasllama_vkbake_{ref_time_ticks()}.dlim")
+            let tag = moe_gpu_bake_tag()
+            t |> success(!empty(tag), "the armed tier names its bake tag")
+            t |> success(save_model_image(m, img, tag, "q8"), "flavor image saves")
+            var b = Model()
+            t |> success(load_model_image(img, b, tag), "flavor image maps")
+            t |> equal(long_length(m.vkplan), long_length(b.vkplan), "plan survives the round trip")
+            t |> equal(long_length(m.vkblob), long_length(b.vkblob), "blob survives the round trip")
+            delete b
+            delete m
+            remove(img)
+        }
+    }
+}

From 2dd0dea33cf784ccd0d8bc2bd4256b0a05656040 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 12:28:35 -0700
Subject: [PATCH 23/30] =?UTF-8?q?dasllama-server:=20the=20.dlim=20surface?=
 =?UTF-8?q?=20=E2=80=94=20per-model=20inventory,=20bake-now,=20automatic?=
 =?UTF-8?q?=20GC,=20flavor=20locks?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Library first: dlim_inventory / dlim_clean / dlim_image_verdict / dlim_current_identities
move into dasllama_image (the converter's --list/--clean refactor onto them), so the
server and the CLI share one implementation.

Server: GET /v1/images lists every slot's .dlim siblings (size, version, verdict,
identity) plus the mapped flavor; POST /bake spawns dasllama-convert as a child on
the bench worker's proven single-spawn shape (quiesced-only, one child at a time,
tune-relaunch retry, the converter's receipt lines surface in the log) — planar
slots stream, the GPU owner bakes the vulkan flavor against the server's LIVE
config via a --config handoff; GET /bake serves state/log. The dlim GC (only
never-loadable images) runs at server start and on every bake completion.
ModelSlot carries its source GGUF path; /v1/stats slots grow `flavor`.

Page (existing forge style): each model card gets a .dlim line (serving flavor,
current/stale counts, total GB, per-file tooltip) and a bake button with completion
polling; config GPU knobs lock while the active slot serves a flavor image — a
vulkan .dlim cannot switch to cpu mode, the knobs are baked into the file.

Gates: server suite 19/19 (new /v1/images + /bake decline arms) with a live
tinyllama server; live end-to-end smoke: startup GC reclaimed 7292 MB from 4 stale
images, POST /bake spawned the converter, streamed 1299 MB in 18.5 s to the
identity path, completion drained with receipts, clean shutdown. env-registry
14/14 (no new knobs); lint + format clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/dasllama/dasllama_image.das |  78 ++++++
 utils/dasllama-convert/main.das              |  93 ++-----
 utils/dasllama-server/control.html           |  93 +++++++
 utils/dasllama-server/main.das               |  11 +-
 utils/dasllama-server/openai_server.das      | 263 ++++++++++++++++++-
 utils/dasllama-server/test_openai_server.das |  33 +++
 6 files changed, 501 insertions(+), 70 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_image.das b/modules/dasLLAMA/dasllama/dasllama_image.das
index e1a6a26445..68174a3937 100644
--- a/modules/dasLLAMA/dasllama/dasllama_image.das
+++ b/modules/dasLLAMA/dasllama/dasllama_image.das
@@ -119,6 +119,84 @@ def image_peek(path : string) : DlimPeek {
     return p
 }
 
+//! One .dlim sibling of a GGUF, as list/GC tooling sees it (converter --list, the server page).
+struct DlimImageInfo {
+    file : string         //!< basename
+    path : string
+    bytes : int64
+    version : int
+    verdict : string      //!< CURRENT | OTHER | STALE vN | BROKEN
+    identity : string
+}
+
+//! The identities THIS box would produce right now, across flavors and quants — the CURRENT
+//! verdict's reference set. Callers pin the box profile first (same ordering as the load path).
+def dlim_current_identities : table<string> {
+    var idents : table<string>
+    for (q in ["q8", "fp32", "q4_0"]) {
+        idents |> insert(image_identity("", q))
+        idents |> insert(image_identity(METAL_IMAGE_TAG, q))
+        let vk = moe_gpu_bake_tag()
+        if (vk != "") {
+            idents |> insert(image_identity(vk, q))
+        }
+    }
+    return <- idents
+}
+
+def dlim_image_verdict(p : DlimPeek; current : table<string>) : string {
+    if (!p.valid) {
+        return "BROKEN"
+    }
+    if (p.version != IMAGE_VERSION) {
+        return "STALE v{p.version}"
+    }
+    return key_exists(current, p.identity) ? "CURRENT" : "OTHER"
+}
+
+//! Every .dlim beside `gguf_path` (or in a directory), with sizes and verdicts.
+def dlim_inventory(gguf_path : string) : array<DlimImageInfo> {
+    var out : array<DlimImageInfo>
+    var st : FStat
+    if (!stat(gguf_path, st)) {
+        return <- out
+    }
+    let dirp = st.is_dir ? gguf_path : dir_name(gguf_path)
+    let base = st.is_dir ? "" : base_name(gguf_path)
+    var current <- dlim_current_identities()
+    dir(dirp) $(name : string) {
+        if (!(name |> ends_with(".dlim")) || (base != "" && !(name |> starts_with(base)))) {
+            return
+        }
+        let full = path_join(dirp, name)
+        let p = image_peek(full)
+        out |> push(DlimImageInfo(file = name, path = full, bytes = p.bytes, version = p.version,
+                                  verdict = dlim_image_verdict(p, current), identity = p.identity))
+    }
+    delete current
+    return <- out
+}
+
+//! The dlim GC: remove what can never load again (BROKEN + version-stale) beside `gguf_path`.
+//! NEVER a loadable image — OTHER may be another box's bake carried here on purpose.
+//! apply = false is a dry run (stale counted, nothing removed).
+def dlim_clean(gguf_path : string; apply : bool) : tuple<total : int; stale : int; removed : int; freed : int64> {
+    var r = (total = 0, stale = 0, removed = 0, freed = 0l)
+    var inv <- dlim_inventory(gguf_path)
+    for (im in inv) {
+        r.total++
+        continue if (im.verdict != "BROKEN" && !(im.verdict |> starts_with("STALE")))
+        r.stale++
+        if (apply && remove(im.path)) {
+            r.removed++
+            r.freed += im.bytes
+            to_log(LOG_INFO, "dasLLAMA image: GC removed {im.file} ({im.bytes >> 20l} MB, {im.verdict})\n")
+        }
+    }
+    delete inv
+    return r
+}
+
 def private pad_to_page(cur : uint64) : uint64 {
     let page = uint64(IMAGE_PAGE)
     return (cur + page - 1ul) / page * page
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index ec34c793af..5444ba7633 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -138,84 +138,43 @@ def private quant_from_string(s : string; var q : QuantMode&) : bool {
     return true
 }
 
-// identities this box would produce right now, across flavors and quants — the CURRENT verdict
-def private current_identities : table<string> {
-    var idents : table<string>
-    for (q in ["q8", "fp32", "q4_0"]) {
-        idents |> insert(image_identity("", q))
-        idents |> insert(image_identity(METAL_IMAGE_TAG, q))
-        let vk = moe_gpu_bake_tag()
-        if (vk != "") {
-            idents |> insert(image_identity(vk, q))
-        }
-    }
-    return <- idents
-}
-
-def private image_verdict(p : DlimPeek; current : table<string>) : string {
-    if (!p.valid) {
-        return "BROKEN"
-    }
-    if (p.version != IMAGE_VERSION) {
-        return "STALE v{p.version}"
-    }
-    return key_exists(current, p.identity) ? "CURRENT" : "OTHER"
-}
-
-// list = the inventory; clean = GC of what can never load again (BROKEN + version-stale).
-// A loadable image is NEVER removed: OTHER may be another box's bake carried here on purpose.
+// list = the inventory; clean = GC of what can never load again (both via the dasllama_image
+// library — the server's /v1/images + startup GC ride the same functions)
 def private list_images(cfg : ConvertArgs) : int {
     var st : FStat
     if (!stat(cfg.model, st)) {
         to_log(LOG_ERROR, "dasllama-convert: no such path '{cfg.model}'\n")
         return 2
     }
-    let dirp = st.is_dir ? cfg.model : dir_name(cfg.model)
-    let base = st.is_dir ? "" : base_name(cfg.model)
-    var current <- current_identities()
-    var n = 0
-    var stale = 0
-    var removed = 0
-    var freed = 0l
-    dir(dirp) $(name : string) {
-        if (!(name |> ends_with(".dlim")) || (base != "" && !(name |> starts_with(base)))) {
-            return
-        }
-        let full = path_join(dirp, name)
-        let p = image_peek(full)
-        let verdict = image_verdict(p, current)
-        n++
-        if (!cfg.clean) {
-            let idnote = empty(p.identity) ? "" : "  {p.identity}"
-            to_log(LOG_INFO, "dasllama-convert: {name}\n")
-            to_log(LOG_INFO, "dasllama-convert:   {p.bytes >> 20l} MB  v{p.version}  {verdict}{idnote}\n")
-            return
-        }
-        return if (p.valid && p.version == IMAGE_VERSION)   // CURRENT or OTHER: loadable — stays
-        stale++
-        if (!cfg.apply) {
-            to_log(LOG_INFO, "dasllama-convert: would remove {name} ({p.bytes >> 20l} MB, {verdict})\n")
-            return
+    if (!cfg.clean) {
+        var inv <- dlim_inventory(cfg.model)
+        for (im in inv) {
+            let idnote = empty(im.identity) ? "" : "  {im.identity}"
+            to_log(LOG_INFO, "dasllama-convert: {im.file}\n")
+            to_log(LOG_INFO, "dasllama-convert:   {im.bytes >> 20l} MB  v{im.version}  {im.verdict}{idnote}\n")
         }
-        if (remove(full)) {
-            removed++
-            freed += p.bytes
-            to_log(LOG_INFO, "dasllama-convert: removed {name} ({p.bytes >> 20l} MB, {verdict})\n")
-        } else {
-            to_log(LOG_WARNING, "dasllama-convert: could not remove {name} — in use?\n")
+        to_log(LOG_INFO, "dasllama-convert: {length(inv)} image(s)\n")
+        delete inv
+        return 0
+    }
+    if (!cfg.apply) {
+        var inv <- dlim_inventory(cfg.model)
+        for (im in inv) {
+            if (im.verdict == "BROKEN" || im.verdict |> starts_with("STALE")) {
+                to_log(LOG_INFO, "dasllama-convert: would remove {im.file} ({im.bytes >> 20l} MB, {im.verdict})\n")
+            }
         }
+        delete inv
     }
-    if (!cfg.clean) {
-        to_log(LOG_INFO, "dasllama-convert: {n} image(s)\n")
-    } elif (cfg.apply) {
-        to_log(LOG_INFO, "dasllama-convert: removed {removed} of {stale} stale image(s), reclaimed {freed >> 20l} MB\n")
+    let r = dlim_clean(cfg.model, cfg.apply)
+    if (cfg.apply) {
+        to_log(LOG_INFO, "dasllama-convert: removed {r.removed} of {r.stale} stale image(s), reclaimed {r.freed >> 20l} MB\n")
+        if (!st.is_dir) {
+            sweep_stale_tmp(cfg.model)
+        }
     } else {
-        to_log(LOG_INFO, "dasllama-convert: {stale} stale of {n} image(s) — rerun with --apply to remove\n")
-    }
-    if (cfg.clean && cfg.apply && !st.is_dir) {
-        sweep_stale_tmp(cfg.model)
+        to_log(LOG_INFO, "dasllama-convert: {r.stale} stale of {r.total} image(s) — rerun with --apply to remove\n")
     }
-    delete current
     return 0
 }
 
diff --git a/utils/dasllama-server/control.html b/utils/dasllama-server/control.html
index 027a1f0975..5bf19ca3f2 100644
--- a/utils/dasllama-server/control.html
+++ b/utils/dasllama-server/control.html
@@ -480,6 +480,73 @@
 // received the GPU tier; its ms comes from the sw totals delta. Polls a second apart can merge
 // two switches into one chip — accepted for an admin surface.
 const slotHitHist = new Map();   // slot name -> rolling cumulative prefix-hit-rate series
+// ===== .dlim inventory + bake (refreshed on load and when a bake completes, not per poll) =====
+const imagesBySlot = new Map();  // slot name -> { flavor, trimmed, images: [{file,bytes,version,verdict}] }
+let bakingModel = "";
+let bakePolling = false;
+
+async function refreshImages() {
+    try {
+        const r = await fetch("/v1/images", { cache: "no-store" });
+        const j = await r.json();
+        imagesBySlot.clear();
+        for (const m of j.models || []) imagesBySlot.set(m.model, m);
+        bakingModel = j.baking || "";
+        if (bakingModel) pollBake();
+    } catch (_e) { /* server may be gone */ }
+}
+
+function pollBake() {
+    if (bakePolling) return;
+    bakePolling = true;
+    const tick = async () => {
+        try {
+            const r = await fetch("/bake", { cache: "no-store" });
+            const j = await r.json();
+            bakingModel = j.state === "running" ? j.model : "";
+            if (j.state === "running") { setTimeout(tick, 2000); return; }
+            if (j.state === "done" || j.state === "failed") {
+                $("m-note").textContent = "bake " + j.state + " (" + j.model + ")" +
+                    (j.state === "failed" && j.log && j.log.length ? " — " + j.log[j.log.length - 1] : "");
+                refreshImages();
+            }
+        } catch (_e) { /* server may be gone */ }
+        bakePolling = false;
+    };
+    setTimeout(tick, 2000);
+}
+
+function dlimLine(m) {
+    const inv = imagesBySlot.get(m.name);
+    if (!inv) return "";
+    const imgs = inv.images || [];
+    const cur = imgs.filter(x => x.verdict === "CURRENT").length;
+    const stale = imgs.filter(x => x.verdict === "BROKEN" || x.verdict.startsWith("STALE")).length;
+    const gb = imgs.reduce((a, x) => a + x.bytes, 0) / 1e9;
+    const serving = inv.flavor ? "serving " + inv.flavor + (inv.trimmed ? " (trimmed)" : "") : "no image mapped";
+    const tip = imgs.map(x => x.file + " — " + (x.bytes / 1e9).toFixed(1) + " GB · v" + x.version + " · " + x.verdict).join("\n");
+    const bakeBit = bakingModel === m.name ? ' · <span class="chip">baking…</span>'
+        : (bakingModel ? "" : ' · <button class="mini xs" type="button" data-bake="' + esc(m.name).replace(/"/g, "&quot;") + '">bake</button>');
+    return '<div class="line dim" title="' + esc(tip) + '">.dlim ' + serving + ' · ' +
+        (imgs.length ? cur + " current" + (stale ? " / " + stale + " stale" : "") + " · " + gb.toFixed(1) + " GB" : "none baked") +
+        bakeBit + '</div>';
+}
+
+// serving from a flavor image bakes the matching knobs into the file — flipping them under a
+// mapped .dlim cannot take effect (a vulkan image cannot switch to cpu mode); lock + hint
+function lockGpuControls(flavor) {
+    const vk = flavor === "vulkan";
+    const locked = vk || flavor === "metal";
+    const hint = locked ? "locked: serving a " + flavor + " .dlim — rebake to change" : "";
+    const ids = vk ? ["f-gpu", "f-gpu_layers", "f-gpu_stream", "f-gpu_vram_mb", "f-gpu_dn", "f-gpu_attn", "f-gpu_dense"] : ["f-gpu"];
+    for (const id of ["f-gpu", "f-gpu_layers", "f-gpu_stream", "f-gpu_vram_mb", "f-gpu_dn", "f-gpu_attn", "f-gpu_dense"]) {
+        const el = document.getElementById(id);
+        if (!el) continue;
+        const on = locked && ids.includes(id);
+        el.disabled = on;
+        el.title = on ? hint : "";
+    }
+}
 const swHist = [];               // newest first: { from, to, ms }
 let prevSlots = null;            // last poll's models[] keyed by name
 
@@ -534,12 +601,15 @@
             '<div class="line dim">' + (m.last_used_s < 0 ? 'never used' : 'used ' + fmtAge(m.last_used_s) + ' ago') +
                 (m.sw_count > 0 ? ' · ' + m.sw_count + ' switch-in' + (m.sw_count > 1 ? 's' : '') +
                     ' · avg ' + m.sw_avg_ms.toFixed(0) + 'ms' : '') + '</div>' +
+            dlimLine(m) +
             '<canvas class="mspark" height="26" title="prefix-cache hit rate"></canvas>';
         draw(el.querySelector("canvas"), [{ data: hh, color: css("--green") }]);
     }
     for (const el of [...box.querySelectorAll(".mcard")]) {
         if (!want.has(el.id)) el.remove();
     }
+    const act = slots.find(x => x.is_active);
+    lockGpuControls(act ? (act.flavor || "") : "");
     if (s.gpu_budget_bytes > 0) {
         $("vram-panel").style.display = "block";
         const owner = slots.find(m => m.holds_gpu);
@@ -558,6 +628,28 @@
 }
 
 $("mcards").addEventListener("click", async e => {
+    const bk = e.target.closest("button[data-bake]");
+    if (bk) {
+        bk.disabled = true;
+        try {
+            const r = await fetch("/bake", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ model: bk.dataset.bake }),
+            });
+            const j = await r.json().catch(() => null);
+            if (r.ok && j) {
+                bakingModel = j.model;
+                $("m-note").textContent = "baking " + j.model + " (" + j.flavor + ") — the converter runs as a child, hold on";
+                pollBake();
+            } else {
+                $("m-note").textContent = j && j.error ? j.error.message : "bake failed: " + r.status;
+            }
+        } catch (_e) {
+            $("m-note").textContent = "bake request failed";
+        }
+        return;
+    }
     const b = e.target.closest("button[data-activate]");
     if (!b) return;
     b.disabled = true;
@@ -1826,6 +1918,7 @@
 
 poll();
 loadConfig();
+refreshImages();
 </script>
 </body>
 </html>
diff --git a/utils/dasllama-server/main.das b/utils/dasllama-server/main.das
index 0c4f1d6cae..7540337aa0 100644
--- a/utils/dasllama-server/main.das
+++ b/utils/dasllama-server/main.das
@@ -22,6 +22,7 @@ options stack = 262144   // the forward chain runs deep under the HTTP tick + C+
 
 require openai_server           // the server + route handlers (this directory)
 require dasllama/dasllama       // load_model / QuantMode / load_asr_model
+require dasllama/dasllama_image // dlim_clean — the startup dlim GC
 require dasllama/dasllama_math  // set_dispatch_worker_limit (engine-level knob, not re-exported)
 require llvm/daslib/llvm_tune   // [tune_policy] + tune_status (the injected guard resolves here)
 require daslib/clargs
@@ -822,7 +823,7 @@ def init() {
             opts.kv_dtype_set = true
         }
         opts.mtp = ent.mtp
-        add_model(m, ent.name, opts)   // captures this load's arm outcome + marks onto the slot
+        add_model(m, ent.name, opts, ent.path)   // captures this load's arm outcome + marks onto the slot
         if (gpu == "vulkan" && ent.backend != "cpu") {
             set_slot_gpu_want(ent.name, slot_want)   // the want switch-in re-arms with
         }
@@ -830,6 +831,14 @@ def init() {
     set_default_model(g_models[def_idx].name)
     set_default_max_tokens(g_cfg.max_tokens > 0 ? int64(g_cfg.max_tokens) : 256l)
 
+    // the dlim GC rides server start (and every bake): only never-loadable images go
+    for (ent in g_models) {
+        let gc = dlim_clean(ent.path, true)
+        if (gc.removed > 0) {
+            to_log(LOG_INFO, "dasllama-server: dlim GC reclaimed {gc.freed >> 20l} MB from {gc.removed} stale image(s) beside {base_name(ent.path)}\n")
+        }
+    }
+
     if (!empty(g_cfg.asr)) {
         configure_asr_workers(g_cfg.asr, g_cfg.mmproj, g_cfg.asr_workers > 0 ? g_cfg.asr_workers : 1)
     }
diff --git a/utils/dasllama-server/openai_server.das b/utils/dasllama-server/openai_server.das
index ec8910290a..abfbdfa0dd 100644
--- a/utils/dasllama-server/openai_server.das
+++ b/utils/dasllama-server/openai_server.das
@@ -10,6 +10,8 @@ require dashv/dashv_boost public
 require daslib/json_boost
 require daslib/toml             // write_toml: POST /config persists the authoritative config
 require dasllama/dasllama_math  // gpu_tier_status: the GET /config GPU badge
+require dasllama/dasllama_image   // dlim_inventory / dlim_clean: GET /v1/images + the bake GC
+require dasllama/dasllama_config  // dlim_config_current/json: the bake child's --config payload
 require daslib/defer            // defer() { delete js } — free the parsed request JSON on every exit path
 require daslib/jobque_boost
 require daslib/rtti             // this_context().last_exception inside ASR worker recovery
@@ -54,6 +56,7 @@ struct SlotOpts {
 //! the tick loop steps one slot's scheduler at a time (round-robin over slots with work).
 struct ModelSlot {
     name : string
+    path : string                   // the source GGUF — the bake button + /v1/images key off it
     model : Model = Model()
     sched : Scheduler = Scheduler()
     opts : SlotOpts = SlotOpts()
@@ -155,8 +158,8 @@ var private g_started_at = 0l   // ref_time_ticks at init_server; /v1/stats deri
 //! Append a loaded model as a serving slot (call once per model, before ``run_server``). ``name``
 //! is the id ``/v1/models`` reports and requests route on via their ``"model"`` field. The first
 //! slot added is the default until ``set_default_model`` says otherwise.
-def add_model(var m : Model; name : string; opts : SlotOpts = SlotOpts()) {
-    var slot <- ModelSlot(name = name, is_default = empty(g_slots))
+def add_model(var m : Model; name : string; opts : SlotOpts = SlotOpts(); path : string = "") {
+    var slot <- ModelSlot(name = name, path = path, is_default = empty(g_slots))
     slot.model <- m
     slot.opts = opts
     // the load's arm outcome (routing marks + resident-driver state) belongs to THIS slot:
@@ -524,6 +527,242 @@ def private handle_bench_get(var resp : HttpResponse?) : http_status {
         http_status.OK)
 }
 
+// ===== bake button (the .dlim converter) =====
+// POST /bake spawns dasllama-convert as a child (the bench worker's proven single-spawn shape):
+// planar slots stream (peak ~16 GB regardless of model size), the GPU-owner slot bakes the
+// vulkan flavor against the server's LIVE config (--config, eager — RAM peak ≈ the planes).
+// GET /bake serves state/log. The dlim GC (never-loadable images) runs when a bake completes.
+
+var private g_bake_state = "idle"        // idle | running | done | failed
+var private g_bake_log : array<string>
+var private g_bake_result_json = ""      // "" until a run completes
+var private g_bake_events : Channel?
+var private g_bake_model = ""            // slot name of the running/last bake
+var private g_bake_gguf = ""             // its source path — the completion GC target
+
+struct private BakeEvent {
+    kind : int         // 0 = log line, 1 = done (text = result json), 2 = failed (text = reason)
+    text : string
+}
+
+def private bake_emit(events : Channel?; kind : int; text : string) {
+    events |> push_clone(BakeEvent(kind = kind, text = text))
+}
+
+def private bake_worker(daslang_bin, gguf_path, flavor, cfg_path : string; var events : Channel?&) {
+    // same defer the bench worker carries: a still-held channel at worker exit is std::terminate
+    defer() {
+        events |> release
+    }
+    let t0 = ref_time_ticks()
+    var args <- [daslang_bin, "-jit", path_join(get_das_root(), "utils/dasllama-convert/main.das"), "--",
+                 "-m", gguf_path, "--force"]
+    if (flavor == "vulkan") {
+        args |> push("-f")
+        args |> push("vulkan")
+        if (!empty(cfg_path)) {
+            args |> push("--config")
+            args |> push(cfg_path)
+        }
+        bake_emit(events, 0, "vulkan flavor bakes eagerly — RAM peak is the model's planes; minutes-class on big models")
+    } else {
+        args |> push("--stream")
+    }
+    bake_emit(events, 0, "$ {cmdline(args)}")
+    var out = ""
+    var rc = run_and_capture(args, out, 7200.0)
+    if (rc == 3 && find(out, "restart to apply") >= 0) {
+        // [tune] bootstrap: the child tuned this box's kernels first (the watchdog convention)
+        bake_emit(events, 0, "converter tuned this box's kernels first — relaunching with the winners")
+        out = ""
+        rc = run_and_capture(args, out, 7200.0)
+    }
+    delete args
+    if (!empty(cfg_path)) {
+        remove(cfg_path)
+    }
+    if (rc != 0) {
+        bake_emit(events, 2, "bake failed (rc={rc}) — tail: {slice(out, max(0, length(out) - 300))}")
+        return
+    }
+    // surface the converter's own receipt lines (identity, output path, wrote N MB)
+    peek_data(out) $(bytes) {
+        var at = 0
+        var line_start = 0
+        while (at < length(bytes)) {
+            if (bytes[at] == uint8('\n')) {
+                let line = slice(out, line_start, at)
+                if (find(line, "dasllama-convert:") >= 0) {
+                    bake_emit(events, 0, clone_string(line))
+                }
+                line_start = at + 1
+            }
+            at++
+        }
+    }
+    let elapsed = int64(get_time_usec(t0)) / 1000000l
+    bake_emit(events, 1, "\{\"ok\":true,\"flavor\":{json_str(flavor)},\"elapsed_s\":{elapsed},\"ts\":{created_ts()}}")
+}
+
+def private drain_bake_events() {
+    if (g_bake_events == null) {
+        return
+    }
+    var more = true
+    while (more) {
+        more = g_bake_events |> try_pop_clone() $(ev : BakeEvent#) {
+            if (ev.kind == 0) {
+                g_bake_log |> push(clone_string(ev.text))
+                to_log(LOG_INFO, "dasllama-server: bake: {ev.text}\n")
+            } else {
+                if (ev.kind == 1) {
+                    g_bake_result_json = clone_string(ev.text)
+                    g_bake_state = "done"
+                    to_log(LOG_INFO, "dasllama-server: bake complete ({g_bake_model})\n")
+                } else {
+                    g_bake_log |> push(clone_string(ev.text))
+                    g_bake_state = "failed"
+                    to_log(LOG_WARNING, "dasllama-server: bake failed: {ev.text}\n")
+                }
+                // the GC rides every bake completion (and server start) — never-loadable only
+                if (!empty(g_bake_gguf)) {
+                    let gc = dlim_clean(g_bake_gguf, true)
+                    if (gc.removed > 0) {
+                        g_bake_log |> push("GC reclaimed {gc.freed >> 20l} MB from {gc.removed} stale image(s)")
+                    }
+                }
+            }
+        }
+    }
+}
+
+def private handle_bake_start(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
+    if (g_bake_state == "running") {
+        return resp |> JSON(error_body("a bake is already running", "invalid_request_error"), http_status.CONFLICT)
+    }
+    if (server_bench_running()) {
+        return resp |> JSON(error_body("a benchmark is running — one child at a time", "invalid_request_error"), http_status.CONFLICT)
+    }
+    if (empty(g_daslang_bin)) {
+        return resp |> JSON(
+            error_body("baking needs a source-tree daslang (standalone exe cannot spawn the converter child)", "invalid_request_error"),
+            http_status.BAD_REQUEST)
+    }
+    if (total_active() > 0l || total_queued() > 0l || g_asr_pending > 0) {
+        return resp |> JSON(
+            error_body("streams are active — the converter competes for cores and RAM; drain first, then bake", "invalid_request_error"),
+            http_status.CONFLICT)
+    }
+    var model_field = ""
+    var jerr = ""
+    var js = read_json(string(req.body), jerr)
+    defer() {
+        unsafe {
+            delete js
+        }
+    }
+    if (js != null) {
+        model_field = js?["model"] ?? ""
+    }
+    let si = slot_index(model_field)
+    if (si < 0) {
+        return resp |> JSON(error_body("unknown model '{model_field}'", "invalid_request_error"), http_status.NOT_FOUND)
+    }
+    if (empty(g_slots[si].path)) {
+        return resp |> JSON(error_body("slot '{g_slots[si].name}' has no source path — cannot bake", "invalid_request_error"), http_status.BAD_REQUEST)
+    }
+    // the CURRENT config bakes: the GPU owner's live tier config yields the vulkan flavor,
+    // every other slot bakes the planar (CPU) image this box would map
+    var flavor = "planar"
+    var cfg_path = ""
+    if (si == g_gpu_owner) {
+        let dc = dlim_config_current("{g_slots[si].model.quant}")
+        if (dc.vulkan_on) {
+            flavor = "vulkan"
+            var terr : string
+            let tmp = temp_directory(terr)
+            cfg_path = path_join(empty(tmp) ? "." : tmp, "dasllama_bake_cfg_{ref_time_ticks()}.json")
+            var wrote = false
+            fopen(cfg_path, "wb") $(f) {
+                if (f != null) {
+                    f |> fwrite(dlim_config_json(dc))
+                    wrote = true
+                }
+            }
+            if (!wrote) {
+                return resp |> JSON(error_body("cannot write the bake config to '{cfg_path}'", "server_error"), http_status.INTERNAL_SERVER_ERROR)
+            }
+        }
+    }
+    g_bake_state = "running"
+    delete g_bake_log
+    g_bake_result_json = ""
+    g_bake_model = g_slots[si].name
+    g_bake_gguf = g_slots[si].path
+    let daslang_bin = g_daslang_bin
+    let gguf_path = g_slots[si].path
+    let flavor_c = flavor
+    let cfg_path_c = cfg_path
+    var events_capture = g_bake_events
+    new_thread() <| @capture(= daslang_bin, = gguf_path, = flavor_c, = cfg_path_c, = events_capture) {
+        bake_worker(daslang_bin, gguf_path, flavor_c, cfg_path_c, events_capture)
+    }
+    to_log(LOG_INFO, "dasllama-server: bake started ({g_bake_model}, {flavor})\n")
+    return resp |> JSON("\{\"ok\":true,\"state\":\"running\",\"model\":{json_str(g_bake_model)},\"flavor\":{json_str(flavor)}}", http_status.ACCEPTED)
+}
+
+def private handle_bake_get(var resp : HttpResponse?) : http_status {
+    var log_doc = JV(g_bake_log)
+    let log_json = write_json_compact(log_doc)
+    unsafe {
+        delete log_doc
+    }
+    let result = empty(g_bake_result_json) ? "null" : g_bake_result_json
+    return resp |> JSON(
+        "\{\"state\":{json_str(g_bake_state)},\"model\":{json_str(g_bake_model)},\"log\":{log_json},\"result\":{result}}",
+        http_status.OK)
+}
+
+// the loaded model's image form: which flavor is actually mapped (locks the matching config knobs)
+def private slot_flavor(s : ModelSlot) : string {
+    if (s.model.metal_blob) {
+        return "metal"
+    }
+    if (long_length(s.model.vkplan) > 0l) {
+        return "vulkan"
+    }
+    return s.model.image_map != null ? "planar" : ""
+}
+
+struct private OaiSlotImages {
+    model : string
+    path : string
+    flavor : string       // what THIS process mapped: planar | vulkan | metal | "" (raw gguf)
+    trimmed : bool
+    images : array<DlimImageInfo>
+}
+
+struct private OaiImagesResponse {
+    baking : string       // "" or the slot name a bake is running for
+    models : array<OaiSlotImages>
+}
+
+def private handle_images(var resp : HttpResponse?) : http_status {
+    var out = OaiImagesResponse(baking = g_bake_state == "running" ? g_bake_model : "")
+    out.models |> reserve(length(g_slots))
+    for (s in g_slots) {
+        var e = OaiSlotImages(model = s.name, path = s.path, flavor = slot_flavor(s),
+                              trimmed = s.model.planes_trimmed)
+        if (!empty(s.path)) {
+            e.images <- dlim_inventory(s.path)
+        }
+        out.models |> emplace(e)
+    }
+    let body = sprint_json(out, false)
+    delete out
+    return resp |> JSON(body, http_status.OK)
+}
+
 var private g_hardware_line = ""   // "<cpu> · N worker lanes · <gpu>" — composed once at init_server
 
 // The CPU marketing name: registry on Windows, /proc/cpuinfo on Linux, sysctl on macOS.
@@ -1756,6 +1995,7 @@ struct private OaiSlotStats {
     holds_gpu : bool          // the slot whose VRAM state is armed (the GPU owner)
     backend : string          // requested: auto | cpu | gpu
     backend_effective : string
+    flavor : string           // mapped image form: planar | vulkan | metal | "" (raw gguf) — the page locks matching config knobs
     ctx : int64
     active : int64
     queued : int64
@@ -1853,6 +2093,7 @@ def private handle_stats(var resp : HttpResponse?) : http_status {
             name = s.name, is_default = s.is_default, is_active = i == g_active,
             holds_gpu = i == g_gpu_owner,
             backend = s.opts.backend, backend_effective = s.backend_effective,
+            flavor = slot_flavor(s),
             ctx = s.model.config.seq_len,
             active = n_active(s.sched), queued = n_queued(s.sched),
             admitted = s.sched.n_admitted, finished = s.sched.n_finished,
@@ -2595,6 +2836,15 @@ class OpenAiServer : HvWebServer {
         GET("/bench") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
             return handle_bench_get(resp)
         }
+        POST("/bake") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
+            return handle_bake_start(req, resp)
+        }
+        GET("/bake") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
+            return handle_bake_get(resp)
+        }
+        GET("/v1/images") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
+            return handle_images(resp)
+        }
         POST("/restart") <| @(var req : HttpRequest?; var resp : HttpResponse?) : http_status {
             if (!g_shutdown_requested) {
                 to_log(
@@ -2670,6 +2920,9 @@ def init_server(port : int; max_streams : int64 = 4l; max_queue : int64 = 32l; c
     g_bench_events = unsafe(channel_create())
     g_bench_state = "idle"
     g_bench_result_json = ""
+    g_bake_events = unsafe(channel_create())
+    g_bake_state = "idle"
+    g_bake_result_json = ""
     start_asr_worker_threads()
     if (empty(g_slots)) {
         to_log(LOG_ERROR, "dasllama-server: init_server with no model slots (call set_model/add_model first)\n")
@@ -2745,6 +2998,7 @@ def update_server() : bool {
     g_server->tick()   // drains queued handlers: requests parse + render + submit here
     drain_asr_events(g_server.server)
     drain_bench_events()
+    drain_bake_events()
     reap_disconnected(g_server.server)
     // serialized multi-model stepping: ONE scheduler step per tick, slots with work interleave
     // round-robin. Every step runs under ITS model's routing marks; the GPU tier follows a
@@ -2818,9 +3072,11 @@ def shutdown_server() {
     var asr_jobs = g_asr_jobs
     var asr_events = g_asr_events
     var bench_events = g_bench_events
+    var bake_events = g_bake_events
     g_asr_jobs = null
     g_asr_events = null
     g_bench_events = null
+    g_bake_events = null
     unsafe {
         if (asr_jobs != null) {
             asr_jobs |> channel_remove
@@ -2831,6 +3087,9 @@ def shutdown_server() {
         if (bench_events != null) {
             bench_events |> channel_remove
         }
+        if (bake_events != null) {
+            bake_events |> channel_remove
+        }
     }
     delete g_bench_log
     if (g_mtp_spec_changed) {
diff --git a/utils/dasllama-server/test_openai_server.das b/utils/dasllama-server/test_openai_server.das
index 13df525bea..86493bff70 100644
--- a/utils/dasllama-server/test_openai_server.das
+++ b/utils/dasllama-server/test_openai_server.das
@@ -161,6 +161,39 @@ def test_openai_server(t : T?) {
                     }
                 }
             }
+            // /v1/images — the .dlim inventory surface (set_model registers no path, so the
+            // slot reports an empty inventory; the SHAPE is what the page contracts on)
+            GET("{base_url}/v1/images") $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK))
+                var err : string
+                var js = read_json(string(resp.body), err)
+                t |> success(js != null, "images JSON parses")
+                if (js != null) {
+                    t |> equal(string(js?["baking"] ?? "?"), "")
+                    let ms = js?["models"]
+                    t |> success(ms != null && ms is _array && length(ms as _array) == 1, "one slot listed")
+                    if (ms != null && ms is _array && length(ms as _array) == 1) {
+                        t |> equal(string((ms as _array)[0]?["model"] ?? ""), "test-llm")
+                    }
+                    unsafe {
+                        delete js
+                    }
+                }
+            }
+            // /bake — idle state; POST declines cleanly without a configured spawner
+            GET("{base_url}/bake") $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.OK))
+                var err : string
+                var js = read_json(string(resp.body), err)
+                t |> success(js != null && string(js?["state"] ?? "") == "idle", "bake starts idle")
+                unsafe {
+                    delete js
+                }
+            }
+            POST("{base_url}/bake", "\{}") $(resp) {
+                t |> equal(int(resp.status_code), int(http_status.BAD_REQUEST))
+                t |> success(find(string(resp.body), "source-tree daslang") >= 0, "bake declines without a spawner")
+            }
             // /v1/embeddings — single input: unit-normalized vector of the model's hidden dim
             POST("{base_url}/v1/embeddings", "\{\"input\":\"the quick brown fox\"}") $(resp) {
                 t |> equal(int(resp.status_code), int(http_status.OK))

From 0f5d30681d4dfa3a3fed8b0431e0ad35f952ca42 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 13:30:48 -0700
Subject: [PATCH 24/30] =?UTF-8?q?dlim=20arc=20phase=20A=20remainder:=20cro?=
 =?UTF-8?q?ss-box=20repack-by-numbers=20=E2=80=94=20a=20PC=20bakes=20byte-?=
 =?UTF-8?q?exact=20M1=20images?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The gen repack primitives were already number-parametrized (generic grp<mr>
shuffles); only their number SOURCES were stamp-bound. The repack fns now read
math's active_* layout getters — value-identical to the stamped companions during
normal serving (activation caches from them) — and the getters grow a bake
override: pin_backend_for_bake pins a registered name normally, while a FOREIGN
name (arm64-gen on a PC) arms the override with the target config's numbers and
aliases the identity's reported backend (dlim_backend_name). The q51 family gets
a registered bake pointer (x64-gen keeps disk-order q51 slots) reached through
active_repack_q51 at both load-path call sites. The converter's --config path
uses the new pin; the identity verify stays fail-closed and passes naturally when
the override took.

Gates (the plan's verification #3, run against a live M1 over ssh):
- M1 dump-config -> the PC bakes SmolLM2 Q8_0 with it: identity
  v7|q8|arm64-gen|s16|q8 mr4 b0 g4|kq 8/8/4/8|q51 mr1|nat 1101 — and the file is
  BYTE-IDENTICAL to the M1's own local bake (sha256 506d36a9…6ecd), proving the
  mr4 repack a PC never serves.
- K-quant family: Llama-3.2-1B Q4_K_M cross-baked and M1-baked images identical
  (fa4b678c…b8c0) — covers the differing k6 mr4 and the wscale16 epilogue.
- The M1 MAPS the image (MAPPED:true) and serves it token-exact vs its gguf load
  (16/16 greedy IDS parity).
- PC regression: the 4B streamed bake reproduces the banked SHA (2323ebec…34e7) —
  the getter swap is byte-invisible for same-box bakes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/dasllama/dasllama_common.das |  2 +-
 modules/dasLLAMA/dasllama/dasllama_layout.das |  4 +-
 modules/dasLLAMA/dasllama/dasllama_math.das   | 60 +++++++++++++++++--
 .../dasLLAMA/dasllama/dasllama_math_gen.das   | 25 ++++----
 utils/dasllama-convert/main.das               | 11 +++-
 5 files changed, 80 insertions(+), 22 deletions(-)

diff --git a/modules/dasLLAMA/dasllama/dasllama_common.das b/modules/dasLLAMA/dasllama/dasllama_common.das
index d39065154c..b90a574be0 100644
--- a/modules/dasLLAMA/dasllama/dasllama_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_common.das
@@ -2287,7 +2287,7 @@ def public get_kq_q51_native() : bool {
 def private dlim_cpu_source_impl(var c : DlimCpuConfig) {
     // the one sanctioned backend-select side effect — the identity itself is a pure formatter
     select_matmul_backend_for_load()
-    c.backend = active_kernel_backend()
+    c.backend = dlim_backend_name()   // the cross-box bake's target alias when one is armed
     c.q8_mr = active_q8_layout_mr()
     c.q8_wbias = active_q8_wbias()
     c.q8_kgroup = active_q8_kgroup()
diff --git a/modules/dasLLAMA/dasllama/dasllama_layout.das b/modules/dasLLAMA/dasllama/dasllama_layout.das
index e78439de1c..40a3db13e6 100644
--- a/modules/dasLLAMA/dasllama/dasllama_layout.das
+++ b/modules/dasLLAMA/dasllama/dasllama_layout.das
@@ -217,7 +217,7 @@ def private repack_regions(var t : Model; regs : array<StreamReg>) {
     let rq8 = g_repack_q8q8
     let rkq = g_repack_kq
     let rmx = g_repack_mx4
-    let rq51 = g_repack_q51
+    let rq51 = active_repack_q51()   // override-aware: a cross-box q51 target needs the gen generic
     unsafe {
         var qbp : int8? = null
         var qsp : float? = null
@@ -524,7 +524,7 @@ def private stream_repack_one(fmt : int; qp, sp : void?; n, d : int64) {
         if (fmt == 0) {
             invoke(g_repack_q8q8, reinterpret<int8?>(qp), reinterpret<float?>(sp), n, d)
         } elif (fmt == 2) {
-            invoke(g_repack_q51, reinterpret<uint8?>(qp), reinterpret<uint8?>(sp), n, d)
+            invoke(active_repack_q51(), reinterpret<uint8?>(qp), reinterpret<uint8?>(sp), n, d)
         } else {
             invoke(g_repack_kq, fmt, reinterpret<uint8?>(qp), reinterpret<uint8?>(sp), n, d)
         }
diff --git a/modules/dasLLAMA/dasllama/dasllama_math.das b/modules/dasLLAMA/dasllama/dasllama_math.das
index 30da6a07b6..8fa6ca6e38 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math.das
@@ -2699,27 +2699,77 @@ def private kq_layout_grp4_fmt(fmt : int) : int => 4
 def private q8_wbias_zero() : int => 0
 def private q8_kgroup_four() : int => 4
 
+// ===== cross-box bake: repack by NUMBERS =====
+// The getters below are the one layout authority; a foreign-backend bake overrides them with the target's numbers — the generic grp<mr> repacks produce the exact bytes, and the local kernels never serve them (the foreign identity cannot load here)
+var private g_bake_cpu_override = false
+var private g_bake_cpu = DlimCpuConfig()
+
+//! The backend name the dlim identity reports — the bake alias when a cross-box bake is armed.
+def dlim_backend_name() : string => g_bake_cpu_override ? g_bake_cpu.backend : active_kernel_backend()
+
+//! Pin the backend a bake targets: a registered name pins normally; a FOREIGN name arms
+//! repack-by-numbers (the gen tier's generic grp<mr> primitives produce the target layout,
+//! the identity reports the target backend). false = no route — the caller fail-closes.
+def pin_backend_for_bake(cpu : DlimCpuConfig) : bool {
+    if (key_exists(g_kernel_backends, cpu.backend)) {
+        pin_kernel_backend(cpu.backend)
+        return active_kernel_backend() == cpu.backend
+    }
+    select_matmul_backend_for_load()   // the load enters repack stages only under a repack backend
+    if (!kernel_backend_needs_repack(active_kernel_backend())) {
+        to_log(LOG_WARNING, "dasLLAMA: cross-box bake for '{cpu.backend}' needs the generated repack family — none is active here\n")
+        return false
+    }
+    g_bake_cpu = cpu
+    g_bake_cpu_override = true
+    return true
+}
+
+def clear_bake_backend_override() {
+    g_bake_cpu_override = false
+}
+
 //! The Q8 interleave (mr) of the ACTIVE backend's weight layout — cached at activation from
 //! KernelBackend.q8_layout (4 for every hand tier; the stamped mr on the gen backend).
-def active_q8_layout_mr() : int64 => g_active_q8_layout_mr
+def active_q8_layout_mr() : int64 => g_bake_cpu_override ? g_bake_cpu.q8_mr : g_active_q8_layout_mr
 
 //! The active backend's kq plane interleave for `fmt` (4/5/6) — per-format since the kq v2
 //! family split; the loader freezes these onto the Model at repack time.
-def active_kq_layout_mr(fmt : int) : int64 => int64(invoke(g_active_kq_layout, fmt))
+def active_kq_layout_mr(fmt : int) : int64 {
+    if (g_bake_cpu_override) {
+        return fmt == 4 ? g_bake_cpu.kq_mr4 : (fmt == 5 ? g_bake_cpu.kq_mr5 : (fmt == 40 ? g_bake_cpu.kq_mr40 : g_bake_cpu.kq_mr6))
+    }
+    return int64(invoke(g_active_kq_layout, fmt))
+}
 
 //! The active backend's q51 plane interleave — 1 (disk order) on every hand tier; the stamped
 //! mr on the arm64-gen backend (the self-anchored q51 GEMV family).
-def active_q51_layout_mr() : int64 => g_active_q51_layout_mr
+def active_q51_layout_mr() : int64 => g_bake_cpu_override ? g_bake_cpu.q51_mr : g_active_q51_layout_mr
 
 //! The weight-plane bias of the ACTIVE backend's Q8 layout — cached at activation from
 //! KernelBackend.q8_wbias (0 for every hand tier; 128 on a bias128 gen stamp). The mx4->Q8
 //! expand biases its LUT writes to match.
-def active_q8_wbias() : int64 => g_active_q8_wbias
+def active_q8_wbias() : int64 => g_bake_cpu_override ? g_bake_cpu.q8_wbias : g_active_q8_wbias
 
 //! The plane kgroup of the ACTIVE backend's Q8 layout — cached at activation from
 //! KernelBackend.q8_kgroup (4 for every hand tier; 8 on an smmla gen stamp). The mx4->Q8
 //! expand's positional map and the batch token-tail generic read it.
-def active_q8_kgroup() : int64 => g_active_q8_kgroup
+def active_q8_kgroup() : int64 => g_bake_cpu_override ? g_bake_cpu.q8_kgroup : g_active_q8_kgroup
+
+// the q51 repack for a bake whose target has grp<mr> q51 planes: some LOCAL registrations
+// leave repack_q51 unset (x64-gen keeps disk-order q51 slots), so the gen module registers its
+// generic q51 repack here for the override path to reach
+var private g_bake_q51_repack = @@repack_q51_identity
+
+def set_bake_q51_repack(f : RepackQ51Fn) {
+    g_bake_q51_repack = f
+}
+
+//! The q51 repack the LOAD path invokes — the gen generic under a cross-box override with a
+//! grp<mr> q51 target, else the active backend's slot.
+def active_repack_q51() : RepackQ51Fn {
+    return g_bake_cpu_override && g_bake_cpu.q51_mr > 1l ? g_bake_q51_repack : g_repack_q51
+}
 [unused_argument(yp, wp, sp, xqp, xsp, n, d)]
 def private q8q8_unset_kernel(var yp : float?; wp : int8 const?; sp : float const?; xqp : int8 const?; xsp : float const?; n, d : int64) { no_backend() }
 [unused_argument(yp, wp, sp, xqp, xsp, n, d, ntok)]
diff --git a/modules/dasLLAMA/dasllama/dasllama_math_gen.das b/modules/dasLLAMA/dasllama/dasllama_math_gen.das
index 74b8c0d048..a1c9ff0b59 100644
--- a/modules/dasLLAMA/dasllama/dasllama_math_gen.das
+++ b/modules/dasLLAMA/dasllama/dasllama_math_gen.das
@@ -569,11 +569,11 @@ def repack_q8q8_grp(var wp : int8?; var sp : float?; n, d, mr : int64; wbias : i
     delete ts
 }
 
-// the backend repack slot: layout/wbias/kgroup companions decide interleave, plane bias, and
-// k-byte grouping — so a bias128-mr16 stamp gets biased grp16 weights and an smmla stamp gets
-// the kg8 row-pair plane from the same load path that gives grp4 its plain weights
+// the backend repack slot. Numbers come through math's active_* getters — value-identical to
+// the stamped companions during normal serving (activation caches from them), and the
+// cross-box bake override's one seam
 def private repack_q8q8_gen(var wp : int8?; var sp : float?; n, d : int64) {
-    repack_q8q8_grp(wp, sp, n, d, int64(q8q8_layout_gen()), int64(q8q8_wbias_gen()), int64(q8q8_kgroup_gen()))
+    repack_q8q8_grp(wp, sp, n, d, active_q8_layout_mr(), active_q8_wbias(), active_q8_kgroup())
 }
 
 //! mr-generalized MXFP4 plane repack (mr=4 reproduces the old hand arm64-laneq mx interleave
@@ -626,7 +626,7 @@ def repack_mx4_grp(var np : uint8?; var ep : uint8?; n, d, mr : int64) {
 // the backend mx4 repack slot: same layout companion as the Q8 repack — planes and weights
 // interleave at the ONE stamped mr
 def private repack_mx4_gen(var np : uint8?; var ep : uint8?; n, d : int64) {
-    repack_mx4_grp(np, ep, n, d, int64(q8q8_layout_gen()))
+    repack_mx4_grp(np, ep, n, d, active_q8_layout_mr())
 }
 
 // ===== the q51 GEMV family (self-anchored — q51 does NOT ride the Q8 mr; its grid is
@@ -691,9 +691,9 @@ def repack_q51_grp(var qp : uint8?; var sp : uint8?; n, d, mr : int64) {
     delete ts
 }
 
-// the backend q51 repack slot: the family's OWN layout companion decides the interleave
+// the backend q51 repack slot: the family's layout number via math's override-aware getter
 def private repack_q51_gen(var qp : uint8?; var sp : uint8?; n, d : int64) {
-    repack_q51_grp(qp, sp, n, d, int64(q51q8_layout_gen()))
+    repack_q51_grp(qp, sp, n, d, active_q51_layout_mr())
 }
 
 //! One row's dot off the grp<mr> q51 planes, scalar — the q51 stub's reference body and the
@@ -1136,13 +1136,13 @@ def kq_grp_row_dot_b(fmt : int64; kqg : uint8 const?; ksg : uint8 const?; r, mr
 // the backend kq repack slot: same layout companion as the Q8/mx4 repacks — one stamped mr
 def private repack_kq_gen(fmt : int; var kq : uint8?; var ks : uint8?; n, d : int64) {
     if (fmt == 4) {
-        repack_k4_grp(kq, ks, n, d, int64(k4q8_layout_gen()))
+        repack_k4_grp(kq, ks, n, d, active_kq_layout_mr(4))
     } elif (fmt == 5) {
-        repack_k5_grp(kq, ks, n, d, int64(k5q8_layout_gen()))
+        repack_k5_grp(kq, ks, n, d, active_kq_layout_mr(5))
     } elif (fmt == 40) {
-        repack_q40_grp(kq, ks, n, d, int64(q40q8_layout_gen()))
+        repack_q40_grp(kq, ks, n, d, active_kq_layout_mr(40))
     } else {
-        repack_k6_grp(kq, ks, n, d, int64(k6q8_layout_gen()))
+        repack_k6_grp(kq, ks, n, d, active_kq_layout_mr(6))
     }
 }
 
@@ -2109,6 +2109,9 @@ def private q8q8_groupn_s16_gen(var yp : float?; wp : int8 const?; sp : uint16 c
 
 [init]
 def dasllama_math_gen_register() {
+    // the cross-box override's q51 reach: x64-gen keeps disk-order q51 slots, so the generic
+    // grp<mr> q51 repack registers here for bakes whose TARGET has grp q51 planes
+    set_bake_q51_repack(@@repack_q51_gen)
     // needs_repack keeps this out of auto-select (direct callers stay on arm64-sdot). q8_layout
     // must be evaluated at selection time, not [init] — [init]s run before the JIT installs
     // generated code (the slice C mr8 bug); arm64 needs no availability predicate.
diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 5444ba7633..8dcc1fd26e 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -274,17 +274,22 @@ def main() : int {
             return 2
         }
         // apply what a host can take, then verify FAIL-CLOSED: any knob that did not take
-        // (unavailable backend, missing s16 twins) shows up as an identity mismatch below
+        // (missing s16 twins, no repack family for a foreign backend) shows up as an identity
+        // mismatch below. A FOREIGN backend name arms repack-by-numbers: the local generic
+        // grp<mr> primitives produce the target's exact plane bytes from the config's numbers.
         set_wscale_f16(want.cpu.wscale_f16)
         set_kquant_native(want.cpu.kquant_native)
         set_kq_q40_native(want.cpu.kq_q40_native)
         set_kq_q50_native(want.cpu.kq_q50_native)
         set_kq_q51_native(want.cpu.kq_q51_native)
-        pin_kernel_backend(want.cpu.backend)
+        if (!pin_backend_for_bake(want.cpu)) {
+            to_log(LOG_ERROR, "dasllama-convert: --config targets '{want.cpu.backend}' and this host has no repack family to bake it with\n")
+            return 2
+        }
         let want_ident = dlim_identity(want, IMAGE_VERSION)
         let have_ident = dlim_identity(dlim_config_current(want.quant), IMAGE_VERSION)
         if (have_ident != want_ident) {
-            to_log(LOG_ERROR, "dasllama-convert: --config could not be fully applied on this host (cross-box backend targeting lands later in the arc):\n  want {want_ident}\n  have {have_ident}\n")
+            to_log(LOG_ERROR, "dasllama-convert: --config could not be fully applied on this host:\n  want {want_ident}\n  have {have_ident}\n")
             return 2
         }
         have_want = true

From eee4615c02bf04145f4c57395f934c9e8d3bc669 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 13:38:15 -0700
Subject: [PATCH 25/30] =?UTF-8?q?dlim=20arc:=20dasllama=5Fmetal=5Fshapes?=
 =?UTF-8?q?=20=E2=80=94=20the=20metal=20servable=20predicate=20goes=20port?=
 =?UTF-8?q?able?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Metal drivers' MODEL-SHAPE gates move verbatim into a new portable module
(no das_metal require): the decline enum, MetalNeed + metal_needs/missing/record,
kq_fmt/kq_load GPU-support, kv_share_ok, dn_metal_ok, moe_metal_ok + moe_site_ok,
DECODE/BATCH_NEEDS_OK, decode_shape_decline (public now), and the mint-time
metal_model_servable_impl, whose [init] registration now fires on EVERY build —
the piece that build-locked metal-flavor baking to Apple. dasllama_metal_common
re-exports the module so the Apple driver family keeps its names; the umbrella
requires it unconditionally. The runtime gates (device, PSO, planar, mirrors)
stay in the metal modules.

PC compile + full dlim chain green; the Apple-side build/lint validation runs on
the M1 next (the metal modules cannot compile on Windows).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 modules/dasLLAMA/.das_module                  |   2 +-
 .../dasllama/dasllama_metal_common.das        | 265 +------------
 .../dasllama/dasllama_metal_llama.das         |  69 ----
 .../dasllama/dasllama_metal_shapes.das        | 361 ++++++++++++++++++
 .../dasllama/dasllama_transformer.das         |   1 +
 5 files changed, 364 insertions(+), 334 deletions(-)
 create mode 100644 modules/dasLLAMA/dasllama/dasllama_metal_shapes.das

diff --git a/modules/dasLLAMA/.das_module b/modules/dasLLAMA/.das_module
index 3783b947a4..dc88dd079a 100644
--- a/modules/dasLLAMA/.das_module
+++ b/modules/dasLLAMA/.das_module
@@ -4,7 +4,7 @@ require daslib/fio
 [export]
 def initialize(project_path : string) {
     let dasllama_paths = [
-        "dasllama_env", "dasllama_config", "dasllama_par", "dasllama_parity", "dasllama_tune", "dasllama_math", "dasllama_math_default", "dasllama_math_aarch64_neon", "dasllama_math_gen", "dasllama_math_metal", "dasllama_math_vulkan", "dasllama_math_accelerate", "dasllama_kernel_access", "dasllama_vulkan_lens", "dasllama_metal_lens", "dasllama_metal_common", "dasllama_metal_kernels", "dasllama_metal_prefill", "dasllama_metal_llama", "dasllama_gemm_gen", "dasllama_gemm_register", "dasllama_gemm_schema", "dasllama_quant", "dasllama_gguf",
+        "dasllama_env", "dasllama_config", "dasllama_par", "dasllama_parity", "dasllama_tune", "dasllama_math", "dasllama_math_default", "dasllama_math_aarch64_neon", "dasllama_math_gen", "dasllama_math_metal", "dasllama_math_vulkan", "dasllama_math_accelerate", "dasllama_kernel_access", "dasllama_vulkan_lens", "dasllama_metal_lens", "dasllama_metal_shapes", "dasllama_metal_common", "dasllama_metal_kernels", "dasllama_metal_prefill", "dasllama_metal_llama", "dasllama_gemm_gen", "dasllama_gemm_register", "dasllama_gemm_schema", "dasllama_quant", "dasllama_gguf",
         "dasllama_unicode", "dasllama_tokenizer", "dasllama_bpe", "dasllama_common", "dasllama_layout", "dasllama_prefix", "dasllama_audio", "dasllama_audio_io", "dasllama_whisper", "dasllama_qwen3a", "dasllama_parakeet", "dasllama_canary", "dasllama_gemma4a", "dasllama_vad", "dasllama_asr",
         "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_gptoss", "dasllama_arch_mistral3", "dasllama_arch_glm4moe", "dasllama_image",
         "dasllama_transformer", "dasllama_chat", "dasllama"
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_common.das b/modules/dasLLAMA/dasllama/dasllama_metal_common.das
index 085917eada..18b1bae376 100644
--- a/modules/dasLLAMA/dasllama/dasllama_metal_common.das
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_common.das
@@ -10,6 +10,7 @@ require dasllama/dasllama_env  // env_int/env_flag: the shared typed readers + t
 require metal/das_metal_boost
 require dasllama/dasllama_common
 require dasllama/dasllama_math
+require dasllama/dasllama_metal_shapes public   // the extracted portable shape gates — re-exported so the driver family keeps its names
 
 // Shared infrastructure for the dasMetal resident drivers (the format-matrix arc's W1 split):
 // device/queue init, buffer pools, the weight-region + block_q8_0-blob + cat-blob caches, the
@@ -34,111 +35,6 @@ var g_attn_single_max = 64l
 // the fused add+rms kernel's threadgroup row slab — wider models take the unfused pair
 let ADD_RMS_MAX_DIM = 4096l
 
-// why a step declined to the CPU path — every gate reports its FIRST failing clause, and the
-// declines-by-reason tables make silent coverage regressions observable (the support-matrix test
-// asserts these names as strings; renaming a value is a test-visible change)
-enum MetalDecodeDecline {
-    none                // supported — the step runs on the GPU
-    quant_mode          // weights not loaded under QuantMode.q8
-    kquant_native       // per-tensor K-quant planes: not readable as qblob offsets (kernels = W4)
-    arch                // RETIRED (family waves A): the arch-name check is gone — non-std block
-                        // sets decline `graph`, feature-flag configs decline `feature` per bit
-    backend_repack      // repack backend: interleaved weight layout unreadable by the GPU kernels
-    rope_mode           // rope tables off
-    config              // RETIRED (family waves A): split into `feature` + the per-need
-                        // `need_*` keys in the declines-by-reason table
-    graph               // block set is not the std dense stack (MoE / recurrent / custom attn)
-    feature             // the model needs layer-stack features this path's kernels don't
-                        // implement — each missing bit records a `need_*` key alongside
-    shape               // head/dim alignment outside the kernel grids
-    layers              // per-layer non-uniformity (kv_dim/head_size/hidden/sliding/missing wv)
-    kv_dtype            // session KV codec not uniform f16/f32 (the mirror moves raw row bytes)
-    depth               // RETIRED (M2.4): the chunked/partD attention scans any depth — capacity
-                        // limits surface as `mirror` (the arena cannot hold the session's slice)
-    no_uid              // session without a real uid (mirror keying)
-    rope_rows           // the position's rope row not built
-    batch_dim_cap       // RETIRED (M2.6): the batch add+rms falls back to the unfused pair past
-                        // the fused slab, and the GEMM's fixed K-tiles serve any dim at B > 4
-    device              // metal_decode_init failed (no device / PSO build failure)
-    mirror              // the mirror arena cannot hold the KV slice
-    gpu_error           // dispatch failed at execution time
-    planar              // weights not in the blob-image form (the drivers are blob-only —
-                        // load_model under metal mode transforms/maps the metal flavor)
-    dn_state            // deltanet recurrent state not GPU-resident for this position (state is
-                        // forward-only and NOT re-derivable — no watermark repair exists)
-}
-
-//! Layer-stack features a model's graph needs beyond the base llama dense block — ONE derivation
-//! (`metal_needs`) feeds every GPU gate; each path holds its own implemented-set mask and declines
-//! `feature` on the difference, recording a `need_*` key per missing bit.
-bitfield MetalNeed {
-    neox            // NEOX rope pairing (j, j+hs/2) — qwen2/qwen3/phi3/gemma/gptoss
-    qkv_bias        // additive bias on the Q/K/V projections — qwen2/glm4moe/gptoss
-    qk_norm         // per-head RMSNorm on Q/K before rope — qwen3/gemma3+/qwen35
-    v_norm          // weightless per-head RMSNorm on V — gemma4
-    partial_rope    // rope_dim < head_size rotates only the first rope_dim dims — qwen35/glm4moe
-    q_gated         // 2x-wide Q, out ⊙ σ(gate) before wo — qwen35
-    attn_scale      // attention-score scale override (not 1/sqrt(hs)) — gemma4
-    softcap         // attention-logit soft cap — gemma2
-    sliding         // sliding-window attention span — gemma2/3/4, gptoss
-    sinks           // per-head sink logit in the softmax denominator — gptoss
-    out_bias        // additive bias on the attention output projection — gptoss
-    pre_post_norm   // extra post-attention / post-FFN norms — gemma2/3/4
-    out_scale       // per-layer scalar on the layer output — gemma4
-    geglu           // GeGLU FFN activation (gelu, not silu) — gemma2/3/4
-    ple             // per-layer embeddings — gemma4 E-series
-    qd_neq_dim      // n_heads*head_size != dim (query width differs from the residual) — qwen3
-}
-
-//! The feature set model `t` needs from a resident GPU driver — derived from the loaded config
-//! (per-file truth: loader-detected flags included). Graph-shape needs are NOT bits here — the
-//! block set declares those (`attn_is_std` / `ffn_is_dense`) and the gates decline `graph` first.
-def metal_needs(t : Model) : MetalNeed {
-    let c = t.config
-    var n : MetalNeed
-    n.neox = c.rope_neox
-    n.qkv_bias = c.attn_qkv_bias
-    n.qk_norm = c.qk_norm
-    n.v_norm = c.v_norm
-    n.partial_rope = c.rope_dim > 0l && c.rope_dim != c.head_size
-    n.q_gated = c.q_gated
-    n.attn_scale = c.attn_scale > 0.0
-    n.softcap = c.attn_logit_softcap > 0.0
-    n.sliding = c.sliding_window > 0l
-    n.sinks = c.attn_sinks
-    n.out_bias = c.attn_out_bias
-    n.pre_post_norm = c.pre_post_norm
-    n.out_scale = c.layer_out_scale
-    n.geglu = c.ffn_act != FfnAct.silu
-    n.ple = c.n_embd_per_layer > 0l
-    n.qd_neq_dim = c.n_heads * c.head_size != c.dim
-    return n
-}
-
-def metal_missing_needs(t : Model; ok : MetalNeed) : MetalNeed {
-    return metal_needs(t) & ~ok
-}
-
-// one `need_*` key per missing bit — the support-matrix cells assert these names as strings
-def record_needs(var tab : table<string; int64>; missing : MetalNeed) {
-    if (missing.neox) { tab["need_neox"]++ }
-    if (missing.qkv_bias) { tab["need_qkv_bias"]++ }
-    if (missing.qk_norm) { tab["need_qk_norm"]++ }
-    if (missing.v_norm) { tab["need_v_norm"]++ }
-    if (missing.partial_rope) { tab["need_partial_rope"]++ }
-    if (missing.q_gated) { tab["need_q_gated"]++ }
-    if (missing.attn_scale) { tab["need_attn_scale"]++ }
-    if (missing.softcap) { tab["need_softcap"]++ }
-    if (missing.sliding) { tab["need_sliding"]++ }
-    if (missing.sinks) { tab["need_sinks"]++ }
-    if (missing.out_bias) { tab["need_out_bias"]++ }
-    if (missing.pre_post_norm) { tab["need_pre_post_norm"]++ }
-    if (missing.out_scale) { tab["need_out_scale"]++ }
-    if (missing.geglu) { tab["need_geglu"]++ }
-    if (missing.ple) { tab["need_ple"]++ }
-    if (missing.qd_neq_dim) { tab["need_qd_neq_dim"]++ }
-}
-
 var g_dev : MetalDevice?
 var g_queue : MetalCommandQueue?
 var g_failed = false
@@ -691,35 +587,6 @@ def mx4_of(dev : MetalDevice?; t : Model; off : int64) : tuple<qbuf : MetalBuffe
     }
 }
 
-// the kq formats the Metal kernels implement — anything else (the q4_0 QAT tier, future
-// formats) must DECLINE kquant_native instead of falling into a wrong-layout kernel branch
-// (the dispatchers below treat "not k4/k6" as k5)
-def kq_fmt_gpu_supported(f : KqFmt) : bool {
-    return f == KqFmt.q8 || f == KqFmt.k4 || f == KqFmt.k5 || f == KqFmt.k6
-}
-
-def private kq_fmts_gpu_supported(a : array<KqFmt>) : bool {
-    for (f in a) {
-        if (!kq_fmt_gpu_supported(f)) {
-            return false
-        }
-    }
-    return true
-}
-
-// every tensor fmt a kq load can route to a GPU kernel — the decode/batch/prefill gates all
-// clause on this (the MoE expert planes never reach the llama-family GPU graph, so we1/2/3
-// stay out of scope)
-def kq_load_gpu_supported(t : Model) : bool {
-    if (!t.kquant_native) {
-        return true
-    }
-    return ((kq_fmts_gpu_supported(t.wq_fmt) && kq_fmts_gpu_supported(t.wk_fmt) &&
-             kq_fmts_gpu_supported(t.wv_fmt) && kq_fmts_gpu_supported(t.wo_fmt)) &&
-        (kq_fmts_gpu_supported(t.w1_fmt) && kq_fmts_gpu_supported(t.w2_fmt) &&
-             kq_fmts_gpu_supported(t.w3_fmt)) &&
-        (kq_fmt_gpu_supported(t.wcls_fmt) && kq_fmt_gpu_supported(t.emb_fmt)))
-}
 
 // ===== zero-copy logits: bytesNoCopy wrappers over session-owned storage =====
 // Writes land straight into s.logits (no landing memcpy); borrowed, no deallocator. Gated on
@@ -852,26 +719,6 @@ def mirror_evict_to_cap(cap_bytes : uint64; keep : uint64) {
     }
 }
 
-//! Cross-layer KV sharing (gemma-4 E-series): does layer l either own its rows or share a
-//! byte-compatible source? A shared layer aliases its source's mirror slab / prefill panel via
-//! kv_row_prefix, so the source must own rows and match l's class geometry exactly.
-def kv_share_ok(t : Model; l : int64) : bool {
-    if (l >= long_length(t.kv_src)) {   // the MTP draft slab owns its rows
-        return true
-    }
-    let src = t.kv_src[l]
-    if (src == l) {
-        return true
-    }
-    return (src >= 0l && src < l && t.kv_src[src] == src && !layer_is_recurrent(t.config, src) &&
-        layer_kv_dim(t.config, l) == layer_kv_dim(t.config, src) &&
-        layer_head_size(t.config, l) == layer_head_size(t.config, src))
-}
-
-//! true when layer l reads another layer's KV (no rows of its own — Q-only attention)
-def kv_shared_layer(t : Model; l : int64) : bool {
-    return l < long_length(t.kv_src) && t.kv_src[l] != l
-}
 
 // Hetero-safe per-layer mirror addressing (gemma4's two kv-head classes): every KV codec is
 // linear bytes-per-element for kvd % 32 == 0, so the layout_offsets element prefix scales
@@ -1087,13 +934,6 @@ def mirror_prepare(t : Model; var s : Session; pos : int64) : tuple<ok : bool; k
 }
 
 
-// Wave D serve gate for the deltanet kernel set: fixed d_state 128 (the scan/l2/gate lane math
-// bakes 32 lanes x 4), conv taps <= 8 (hist registers). β/α projections: q8 planes ride the
-// site GEMVs; f32-on-disk (dn_ba_f32) rides the router-slab f32 GEMV off the fblob offsets.
-def dn_metal_ok(t : Model) : bool {
-    let c = t.config
-    return c.ssm_d_state == 128l && c.ssm_d_conv >= 2l && c.ssm_d_conv <= 8l
-}
 
 // ===== deltanet recurrent-state mirrors (Wave D) — per-session GPU S + conv state =====
 // Forward-only, NOT re-derivable: pos 0 zeroes, s.dn_pos == pos syncs from CPU, else decline;
@@ -1221,110 +1061,7 @@ def private moe_fmt_at(a : array<KqFmt>; l : int64) : KqFmt => empty(a) ? KqFmt.
 
 // one MoE weight stack's (fmt, offset) serve check: base offset = the format's BIND alignment
 // (q8/k4/k5 %256, k6's d-plane pair %512); per-expert stride = the in-kernel index unit
-// (q8 32-blocks, kq 256-superblocks — the expert shift is index math, no base multiple)
-def moe_site_ok(fmt : KqFmt; off, ege : int64) : bool {
-    if (fmt == KqFmt.q8) {
-        return off >= 0l && (off % 256l) == 0l && (ege % 32l) == 0l
-    }
-    if (fmt == KqFmt.k4 || fmt == KqFmt.k5) {
-        return off >= 0l && (off % 256l) == 0l && (ege % 256l) == 0l
-    }
-    if (fmt == KqFmt.k6) {
-        return off >= 0l && (off % 512l) == 0l && (ege % 256l) == 0l
-    }
-    if (fmt == KqFmt.q51) {   // per-32 planes: off % 128 keeps the 20B/4B binds 16B-aligned
-        return off >= 0l && (off % 128l) == 0l && (ege % 32l) == 0l
-    }
-    return false
-}
 
-// The MoE serve gate — covered graph shapes: plain routed FFN (qwen3moe, silu, no biases)
-// + optional sigmoid-gated shared expert (qwen35moe), gemma4's dense-shared dual branch, and
-// gpt-oss's mx4 experts (softmax_weight, biases, disk-order). No dense-lead / selection bias.
-def moe_metal_ok(t : Model) : bool {
-    let c = t.config
-    if (!c.moe || c.n_layer_dense_lead > 0l || c.moe_exp_probs ||
-            (c.expert_weights_scale != 0.0 && c.expert_weights_scale != 1.0)) {
-        return false
-    }
-    if (t.experts_mx4) {
-        // gpt-oss: softmax_weight top-k on raw logits, router + per-expert biases, clamped
-        // swiglu, disk-order mx4 stacks (the CPU laneq repack has no GPU carry)
-        if (c.moe_gate != MoeGate.softmax_weight || c.ffn_act != FfnAct.swiglu_oai ||
-                !c.moe_router_bias || !c.moe_exps_bias || c.moe_dense_shexp || c.n_ff_shexp > 0l ||
-                t.mx4_repacked ||
-                t.router_b_off < 0l || t.web1_off < 0l || t.web2_off < 0l || t.web3_off < 0l) {
-            return false
-        }
-    } elif (c.moe_dense_shexp) {
-        if (c.moe_gate != MoeGate.softmax || !c.norm_topk_prob ||
-                c.moe_router_bias || c.moe_exps_bias || c.n_ff_shexp > 0l ||
-                c.ffn_act != FfnAct.gelu || t.moe_router_scale_off < 0l || t.moe_down_scale_off < 0l ||
-                t.rms_pre_ffn2_off < 0l || t.rms_post_ffn1_off < 0l || t.rms_post_ffn2_off < 0l ||
-                long_length(t.w1_offs) < c.n_layers) {
-            return false
-        }
-    } elif (c.moe_gate != MoeGate.softmax ||
-            c.moe_router_bias || c.moe_exps_bias || c.ffn_act != FfnAct.silu) {
-        // norm_topk_prob both ways: renorm = select gmode 0 (qwen3moe/qwen35moe), no-renorm =
-        // gmode 2 (qwen2moe)
-        return false
-    } elif (c.n_ff_shexp > 0l) {
-        // sigmoid-gated shared expert (qwen35moe): q8 wsh planes at base + l*she ride the
-        // dense site kernels — base + stride %256 (bind), nsh %64 (prefill C tiles)
-        let she = c.dim * c.n_ff_shexp
-        if (!c.moe_shexp_gated ||
-                (c.n_ff_shexp % 64l) != 0l || (she % 256l) != 0l ||
-                (t.wsh1_off % 256l) != 0l || (t.wsh2_off % 256l) != 0l || (t.wsh3_off % 256l) != 0l) {
-            return false
-        }
-    }
-    let ne = c.n_expert
-    let k = c.n_expert_used
-    let nfe = c.n_ff_exp
-    let ege = c.dim * nfe
-    // select holds 8 logits per lane (ne <= 256); %64 dims = the gathered mul_mm C tiles
-    if (ne < 1l || ne > 256l || k < 1l || k > 16l || k > ne || nfe <= 0l ||
-            (c.dim % 64l) != 0l || (nfe % 64l) != 0l ||
-            ne * ege > 3800000000l ||   // uint32 in-kernel indices (q8 byte view = elements * 34/32)
-            t.router_off < 0l || empty(t.we1_offs) || empty(t.we2_offs) || empty(t.we3_offs)) {
-        return false
-    }
-    if (t.experts_mx4) {
-        // mx4 binds: nibble bytes at off/2 (%4 => off %8), E8M0 at off/32 (%4 => off %128)
-        if ((ege % 32l) != 0l) {
-            return false
-        }
-        for (l in range64(c.n_layers)) {
-            if (t.we1_offs[l] < 0l || (t.we1_offs[l] % 128l) != 0l ||
-                    t.we2_offs[l] < 0l || (t.we2_offs[l] % 128l) != 0l ||
-                    t.we3_offs[l] < 0l || (t.we3_offs[l] % 128l) != 0l) {
-                return false
-            }
-        }
-        return true
-    }
-    for (l in range64(c.n_layers)) {
-        let f1 = moe_fmt_at(t.we1_fmt, l)
-        let f2 = moe_fmt_at(t.we2_fmt, l)
-        let f3 = moe_fmt_at(t.we3_fmt, l)
-        // per-site alignment + reduction dims: superblock kq kernels iterate whole 256-rows,
-        // q51 whole 32-blocks (+ the mul_mm's 64-col output tiles)
-        let sb1 = f1 == KqFmt.k4 || f1 == KqFmt.k5 || f1 == KqFmt.k6
-        let sb3 = f3 == KqFmt.k4 || f3 == KqFmt.k5 || f3 == KqFmt.k6
-        let sb2 = f2 == KqFmt.k4 || f2 == KqFmt.k5 || f2 == KqFmt.k6
-        if (!moe_site_ok(f1, t.we1_offs[l], ege) ||
-                !moe_site_ok(f2, t.we2_offs[l], ege) ||
-                !moe_site_ok(f3, t.we3_offs[l], ege) ||
-                ((sb1 || sb3) && (c.dim % 256l) != 0l) ||
-                (sb2 && (nfe % 256l) != 0l) ||
-                ((f1 == KqFmt.q51 || f3 == KqFmt.q51) && ((c.dim % 32l) != 0l || (nfe % 64l) != 0l)) ||
-                (f2 == KqFmt.q51 && ((nfe % 32l) != 0l || (c.dim % 64l) != 0l))) {
-            return false
-        }
-    }
-    return true
-}
 
 
 // ===== the range tracker (the dispatch port; since P3 the batch rail's only hazard system) =====
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_llama.das b/modules/dasLLAMA/dasllama/dasllama_metal_llama.das
index 2b872f2fbd..8c4aedad17 100644
--- a/modules/dasLLAMA/dasllama/dasllama_metal_llama.das
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_llama.das
@@ -54,64 +54,7 @@ def public metal_decode_shutdown {
     metal_common_release()
 }
 
-// what each decode path's kernels implement beyond the base llama dense block — grows wave by wave.
-let DECODE_NEEDS_OK = (MetalNeed.neox | MetalNeed.qkv_bias | MetalNeed.qk_norm | MetalNeed.qd_neq_dim |
-    MetalNeed.softcap | MetalNeed.sliding | MetalNeed.pre_post_norm | MetalNeed.geglu |
-    MetalNeed.v_norm | MetalNeed.attn_scale | MetalNeed.out_scale |
-    MetalNeed.sinks | MetalNeed.out_bias | MetalNeed.partial_rope | MetalNeed.q_gated |
-    MetalNeed.ple)
-// q_gated/partial_rope only occur on hybrid models (attn_is_std false), which batch graph-declines;
-// ple (E-series) has no batch arm either — batched steps decline `feature` and fall back per-row
-let BATCH_NEEDS_OK = DECODE_NEEDS_OK & ~MetalNeed.ple   // clear ple explicitly (XOR would re-add it if DECODE ever drops it)
 
-def private decode_shape_decline(t : Model; needs_ok : MetalNeed; allow_moe : bool = false; allow_kv_share : bool = false) : MetalDecodeDecline {
-    if (t.quant != QuantMode.q8) {
-        return MetalDecodeDecline.quant_mode
-    }
-    if (!kq_load_gpu_supported(t)) {   // a fmt without a GPU kernel (the q4_0 QAT tier, ...) must not dispatch
-        return MetalDecodeDecline.kquant_native
-    }
-    // non-std graphs decline; MoE (Wave C) + deltanet hybrid (Wave D) serve when their kernels cover it
-    if ((!t.blocks.attn_is_std && !(t.config.hybrid_deltanet && dn_metal_ok(t))) ||
-            (!t.blocks.ffn_is_dense && !(allow_moe && moe_metal_ok(t)))) {
-        return MetalDecodeDecline.graph
-    }
-    if (kernel_backend_needs_repack(active_kernel_backend())) {
-        return MetalDecodeDecline.backend_repack
-    }
-    if (!get_rope_table_mode()) {
-        return MetalDecodeDecline.rope_mode
-    }
-    if (metal_missing_needs(t, needs_ok) != default<MetalNeed>) {
-        return MetalDecodeDecline.feature
-    }
-    let c = t.config
-    let hidden = layer_hidden(t, 0l)
-    // sliding masking lives on the CHUNKED path only — window >= 128 (the single-form depth ceiling's clamp max) guarantees the single form never sees a masked row; decline tighter
-    if (((c.dim % 32l) != 0l || (hidden % 32l) != 0l) ||
-            (c.sliding_window > 0l && c.sliding_window < 128l)) {
-        return MetalDecodeDecline.shape
-    }
-    // per-CLASS: whole simdgroups; red[16] + the epl <= 16 q-register hoist cap the threadgroup width at 512 (gemma4's global class)
-    for (l in range64(c.n_layers)) {
-        if (layer_is_recurrent(c, l)) {   // no KV, no attention tensors — only the FFN uniformity applies
-            if (layer_hidden(t, l) != hidden) {
-                return MetalDecodeDecline.layers
-            }
-            continue
-        }
-        let hs_l = layer_head_size(c, l)
-        if ((hs_l % 32l) != 0l || hs_l > 512l || (layer_kv_dim(c, l) % 32l) != 0l) {
-            return MetalDecodeDecline.shape
-        }
-        // E-series KV sharing: only the single-stream driver has the Q-only arm (allow_kv_share)
-        if ((t.kv_src[l] != l && !(allow_kv_share && kv_share_ok(t, l))) || layer_hidden(t, l) != hidden) {
-            return MetalDecodeDecline.layers
-        }
-        // a missing attn_v (V = the pre-norm K projection) serves — raw copy without v_norm; both encoded (the CPU mm_qkv shapes)
-    }
-    return MetalDecodeDecline.none
-}
 
 // ... plus the decode-specific gates (uniform f16/f32 KV, attention depth, a real session uid)
 [unused_argument(pos)]   // depth retired (M2.4) — pos stays in the gate signature for future clauses
@@ -147,17 +90,6 @@ def private decode_decline(t : Model; s : Session; pos : int64) : MetalDecodeDec
 
 def private kq_fmt_at(a : array<KqFmt>; l : int64) : KqFmt => empty(a) ? KqFmt.q8 : a[l]
 
-// mint-time servability (register_metal_servable): shape/graph/feature gates only — the planar
-// check is a RUNTIME gate. Tied-fp32 classifiers decline: the blob drivers force GPU logits
-// and have no fp32-table GEMV.
-def private metal_model_servable_impl(t : Model) : bool {
-    let cls_fmt = t.config.shared_weights ? t.emb_fmt : t.wcls_fmt
-    // tied-fp32 classifier declines (no fp32-table GEMV); NextN serves — prefill stashes mtp_h + warms the slab
-    if (t.config.shared_weights && !t.cls_q8 && cls_fmt == KqFmt.q8) {
-        return false
-    }
-    return decode_shape_decline(t, DECODE_NEEDS_OK, true, true) == MetalDecodeDecline.none
-}
 
 // Can the speculative chain feed itself on this model? It needs a GPU embed gather for the
 // argmax winner: the q8 linear copy (cls_q8), or a tied k6 classifier (every K-quant file on
@@ -3308,7 +3240,6 @@ def dasllama_metal_llama_register() {
     register_batch_decode_override("metal", @@metal_batch_decode_forward)
     register_mtp_spec_override("metal", @@metal_mtp_spec_eval)
     register_mtp_seam_override("metal", @@metal_mtp_seam_row)
-    register_metal_servable(@@metal_model_servable_impl)   // load_model's image-flavor gate
     g_env_logits = env_flag("DASLLAMA_METAL_LOGITS", true)
     g_env_batch_mm = env_flag("DASLLAMA_METAL_BATCH_MM", false)
     g_env_attn_d = env_flag("DASLLAMA_METAL_ATTN_D", true)
diff --git a/modules/dasLLAMA/dasllama/dasllama_metal_shapes.das b/modules/dasLLAMA/dasllama/dasllama_metal_shapes.das
new file mode 100644
index 0000000000..080be89113
--- /dev/null
+++ b/modules/dasLLAMA/dasllama/dasllama_metal_shapes.das
@@ -0,0 +1,361 @@
+options gen2
+options _comment_hygiene = true
+
+module dasllama_metal_shapes shared public
+
+require dasllama/dasllama_common
+require dasllama/dasllama_math   // kernel_backend_needs_repack / active_kernel_backend — the repack clause
+
+// The Metal drivers' MODEL-SHAPE gates, extracted PORTABLE (no das_metal require): the decline
+// enum, the feature-bit derivation, and every pure-Model serve gate the mint-time servable
+// predicate needs. This is what lets a PC bake an M1's metal-flavor .dlim — the blob transform
+// (dasllama_layout) was always pure bytes; only these gates were build-locked to Apple.
+// The RUNTIME gates (device, PSO, planar, mirrors) stay in the metal modules.
+
+// why a step declined to the CPU path — every gate reports its FIRST failing clause, and the
+// declines-by-reason tables make silent coverage regressions observable (the support-matrix test
+// asserts these names as strings; renaming a value is a test-visible change)
+enum MetalDecodeDecline {
+    none                // supported — the step runs on the GPU
+    quant_mode          // weights not loaded under QuantMode.q8
+    kquant_native       // per-tensor K-quant planes: not readable as qblob offsets (kernels = W4)
+    arch                // RETIRED (family waves A): the arch-name check is gone — non-std block
+                        // sets decline `graph`, feature-flag configs decline `feature` per bit
+    backend_repack      // repack backend: interleaved weight layout unreadable by the GPU kernels
+    rope_mode           // rope tables off
+    config              // RETIRED (family waves A): split into `feature` + the per-need
+                        // `need_*` keys in the declines-by-reason table
+    graph               // block set is not the std dense stack (MoE / recurrent / custom attn)
+    feature             // the model needs layer-stack features this path's kernels don't
+                        // implement — each missing bit records a `need_*` key alongside
+    shape               // head/dim alignment outside the kernel grids
+    layers              // per-layer non-uniformity (kv_dim/head_size/hidden/sliding/missing wv)
+    kv_dtype            // session KV codec not uniform f16/f32 (the mirror moves raw row bytes)
+    depth               // RETIRED (M2.4): the chunked/partD attention scans any depth — capacity
+                        // limits surface as `mirror` (the arena cannot hold the session's slice)
+    no_uid              // session without a real uid (mirror keying)
+    rope_rows           // the position's rope row not built
+    batch_dim_cap       // RETIRED (M2.6): the batch add+rms falls back to the unfused pair past
+                        // the fused slab, and the GEMM's fixed K-tiles serve any dim at B > 4
+    device              // metal_decode_init failed (no device / PSO build failure)
+    mirror              // the mirror arena cannot hold the KV slice
+    gpu_error           // dispatch failed at execution time
+    planar              // weights not in the blob-image form (the drivers are blob-only —
+                        // load_model under metal mode transforms/maps the metal flavor)
+    dn_state            // deltanet recurrent state not GPU-resident for this position (state is
+                        // forward-only and NOT re-derivable — no watermark repair exists)
+}
+
+//! Layer-stack features a model's graph needs beyond the base llama dense block — ONE derivation
+//! (`metal_needs`) feeds every GPU gate; each path holds its own implemented-set mask and declines
+//! `feature` on the difference, recording a `need_*` key per missing bit.
+bitfield MetalNeed {
+    neox            // NEOX rope pairing (j, j+hs/2) — qwen2/qwen3/phi3/gemma/gptoss
+    qkv_bias        // additive bias on the Q/K/V projections — qwen2/glm4moe/gptoss
+    qk_norm         // per-head RMSNorm on Q/K before rope — qwen3/gemma3+/qwen35
+    v_norm          // weightless per-head RMSNorm on V — gemma4
+    partial_rope    // rope_dim < head_size rotates only the first rope_dim dims — qwen35/glm4moe
+    q_gated         // 2x-wide Q, out ⊙ σ(gate) before wo — qwen35
+    attn_scale      // attention-score scale override (not 1/sqrt(hs)) — gemma4
+    softcap         // attention-logit soft cap — gemma2
+    sliding         // sliding-window attention span — gemma2/3/4, gptoss
+    sinks           // per-head sink logit in the softmax denominator — gptoss
+    out_bias        // additive bias on the attention output projection — gptoss
+    pre_post_norm   // extra post-attention / post-FFN norms — gemma2/3/4
+    out_scale       // per-layer scalar on the layer output — gemma4
+    geglu           // GeGLU FFN activation (gelu, not silu) — gemma2/3/4
+    ple             // per-layer embeddings — gemma4 E-series
+    qd_neq_dim      // n_heads*head_size != dim (query width differs from the residual) — qwen3
+}
+
+//! The feature set model `t` needs from a resident GPU driver — derived from the loaded config
+//! (per-file truth: loader-detected flags included). Graph-shape needs are NOT bits here — the
+//! block set declares those (`attn_is_std` / `ffn_is_dense`) and the gates decline `graph` first.
+def metal_needs(t : Model) : MetalNeed {
+    let c = t.config
+    var n : MetalNeed
+    n.neox = c.rope_neox
+    n.qkv_bias = c.attn_qkv_bias
+    n.qk_norm = c.qk_norm
+    n.v_norm = c.v_norm
+    n.partial_rope = c.rope_dim > 0l && c.rope_dim != c.head_size
+    n.q_gated = c.q_gated
+    n.attn_scale = c.attn_scale > 0.0
+    n.softcap = c.attn_logit_softcap > 0.0
+    n.sliding = c.sliding_window > 0l
+    n.sinks = c.attn_sinks
+    n.out_bias = c.attn_out_bias
+    n.pre_post_norm = c.pre_post_norm
+    n.out_scale = c.layer_out_scale
+    n.geglu = c.ffn_act != FfnAct.silu
+    n.ple = c.n_embd_per_layer > 0l
+    n.qd_neq_dim = c.n_heads * c.head_size != c.dim
+    return n
+}
+
+def metal_missing_needs(t : Model; ok : MetalNeed) : MetalNeed {
+    return metal_needs(t) & ~ok
+}
+
+// one `need_*` key per missing bit — the support-matrix cells assert these names as strings
+def record_needs(var tab : table<string; int64>; missing : MetalNeed) {
+    if (missing.neox) { tab["need_neox"]++ }
+    if (missing.qkv_bias) { tab["need_qkv_bias"]++ }
+    if (missing.qk_norm) { tab["need_qk_norm"]++ }
+    if (missing.v_norm) { tab["need_v_norm"]++ }
+    if (missing.partial_rope) { tab["need_partial_rope"]++ }
+    if (missing.q_gated) { tab["need_q_gated"]++ }
+    if (missing.attn_scale) { tab["need_attn_scale"]++ }
+    if (missing.softcap) { tab["need_softcap"]++ }
+    if (missing.sliding) { tab["need_sliding"]++ }
+    if (missing.sinks) { tab["need_sinks"]++ }
+    if (missing.out_bias) { tab["need_out_bias"]++ }
+    if (missing.pre_post_norm) { tab["need_pre_post_norm"]++ }
+    if (missing.out_scale) { tab["need_out_scale"]++ }
+    if (missing.geglu) { tab["need_geglu"]++ }
+    if (missing.ple) { tab["need_ple"]++ }
+    if (missing.qd_neq_dim) { tab["need_qd_neq_dim"]++ }
+}
+
+// the kq formats the Metal kernels implement — anything else (the q4_0 QAT tier, future
+// formats) must DECLINE kquant_native instead of falling into a wrong-layout kernel branch
+// (the dispatchers below treat "not k4/k6" as k5)
+def kq_fmt_gpu_supported(f : KqFmt) : bool {
+    return f == KqFmt.q8 || f == KqFmt.k4 || f == KqFmt.k5 || f == KqFmt.k6
+}
+
+def private kq_fmts_gpu_supported(a : array<KqFmt>) : bool {
+    for (f in a) {
+        if (!kq_fmt_gpu_supported(f)) {
+            return false
+        }
+    }
+    return true
+}
+
+// every tensor fmt a kq load can route to a GPU kernel — the decode/batch/prefill gates all
+// clause on this (the MoE expert planes never reach the llama-family GPU graph, so we1/2/3
+// stay out of scope)
+def kq_load_gpu_supported(t : Model) : bool {
+    if (!t.kquant_native) {
+        return true
+    }
+    return ((kq_fmts_gpu_supported(t.wq_fmt) && kq_fmts_gpu_supported(t.wk_fmt) &&
+             kq_fmts_gpu_supported(t.wv_fmt) && kq_fmts_gpu_supported(t.wo_fmt)) &&
+        (kq_fmts_gpu_supported(t.w1_fmt) && kq_fmts_gpu_supported(t.w2_fmt) &&
+             kq_fmts_gpu_supported(t.w3_fmt)) &&
+        (kq_fmt_gpu_supported(t.wcls_fmt) && kq_fmt_gpu_supported(t.emb_fmt)))
+}
+
+//! Cross-layer KV sharing (gemma-4 E-series): does layer l either own its rows or share a
+//! byte-compatible source? A shared layer aliases its source's mirror slab / prefill panel via
+//! kv_row_prefix, so the source must own rows and match l's class geometry exactly.
+def kv_share_ok(t : Model; l : int64) : bool {
+    if (l >= long_length(t.kv_src)) {   // the MTP draft slab owns its rows
+        return true
+    }
+    let src = t.kv_src[l]
+    if (src == l) {
+        return true
+    }
+    return (src >= 0l && src < l && t.kv_src[src] == src && !layer_is_recurrent(t.config, src) &&
+        layer_kv_dim(t.config, l) == layer_kv_dim(t.config, src) &&
+        layer_head_size(t.config, l) == layer_head_size(t.config, src))
+}
+
+//! true when layer l reads another layer's KV (no rows of its own — Q-only attention)
+def kv_shared_layer(t : Model; l : int64) : bool {
+    return l < long_length(t.kv_src) && t.kv_src[l] != l
+}
+
+// Wave D serve gate for the deltanet kernel set: fixed d_state 128 (the scan/l2/gate lane math
+// bakes 32 lanes x 4), conv taps <= 8 (hist registers). β/α projections: q8 planes ride the
+// site GEMVs; f32-on-disk (dn_ba_f32) rides the router-slab f32 GEMV off the fblob offsets.
+def dn_metal_ok(t : Model) : bool {
+    let c = t.config
+    return c.ssm_d_state == 128l && c.ssm_d_conv >= 2l && c.ssm_d_conv <= 8l
+}
+
+// (q8 32-blocks, kq 256-superblocks — the expert shift is index math, no base multiple)
+def moe_site_ok(fmt : KqFmt; off, ege : int64) : bool {
+    if (fmt == KqFmt.q8) {
+        return off >= 0l && (off % 256l) == 0l && (ege % 32l) == 0l
+    }
+    if (fmt == KqFmt.k4 || fmt == KqFmt.k5) {
+        return off >= 0l && (off % 256l) == 0l && (ege % 256l) == 0l
+    }
+    if (fmt == KqFmt.k6) {
+        return off >= 0l && (off % 512l) == 0l && (ege % 256l) == 0l
+    }
+    if (fmt == KqFmt.q51) {   // per-32 planes: off % 128 keeps the 20B/4B binds 16B-aligned
+        return off >= 0l && (off % 128l) == 0l && (ege % 32l) == 0l
+    }
+    return false
+}
+
+def private moe_fmt_at(a : array<KqFmt>; l : int64) : KqFmt => empty(a) ? KqFmt.q8 : a[l]
+
+// The MoE serve gate — covered graph shapes: plain routed FFN (qwen3moe, silu, no biases)
+// + optional sigmoid-gated shared expert (qwen35moe), gemma4's dense-shared dual branch, and
+// gpt-oss's mx4 experts (softmax_weight, biases, disk-order). No dense-lead / selection bias.
+def moe_metal_ok(t : Model) : bool {
+    let c = t.config
+    if (!c.moe || c.n_layer_dense_lead > 0l || c.moe_exp_probs ||
+            (c.expert_weights_scale != 0.0 && c.expert_weights_scale != 1.0)) {
+        return false
+    }
+    if (t.experts_mx4) {
+        // gpt-oss: softmax_weight top-k on raw logits, router + per-expert biases, clamped
+        // swiglu, disk-order mx4 stacks (the CPU laneq repack has no GPU carry)
+        if (c.moe_gate != MoeGate.softmax_weight || c.ffn_act != FfnAct.swiglu_oai ||
+                !c.moe_router_bias || !c.moe_exps_bias || c.moe_dense_shexp || c.n_ff_shexp > 0l ||
+                t.mx4_repacked ||
+                t.router_b_off < 0l || t.web1_off < 0l || t.web2_off < 0l || t.web3_off < 0l) {
+            return false
+        }
+    } elif (c.moe_dense_shexp) {
+        if (c.moe_gate != MoeGate.softmax || !c.norm_topk_prob ||
+                c.moe_router_bias || c.moe_exps_bias || c.n_ff_shexp > 0l ||
+                c.ffn_act != FfnAct.gelu || t.moe_router_scale_off < 0l || t.moe_down_scale_off < 0l ||
+                t.rms_pre_ffn2_off < 0l || t.rms_post_ffn1_off < 0l || t.rms_post_ffn2_off < 0l ||
+                long_length(t.w1_offs) < c.n_layers) {
+            return false
+        }
+    } elif (c.moe_gate != MoeGate.softmax ||
+            c.moe_router_bias || c.moe_exps_bias || c.ffn_act != FfnAct.silu) {
+        // norm_topk_prob both ways: renorm = select gmode 0 (qwen3moe/qwen35moe), no-renorm =
+        // gmode 2 (qwen2moe)
+        return false
+    } elif (c.n_ff_shexp > 0l) {
+        // sigmoid-gated shared expert (qwen35moe): q8 wsh planes at base + l*she ride the
+        // dense site kernels — base + stride %256 (bind), nsh %64 (prefill C tiles)
+        let she = c.dim * c.n_ff_shexp
+        if (!c.moe_shexp_gated ||
+                (c.n_ff_shexp % 64l) != 0l || (she % 256l) != 0l ||
+                (t.wsh1_off % 256l) != 0l || (t.wsh2_off % 256l) != 0l || (t.wsh3_off % 256l) != 0l) {
+            return false
+        }
+    }
+    let ne = c.n_expert
+    let k = c.n_expert_used
+    let nfe = c.n_ff_exp
+    let ege = c.dim * nfe
+    // select holds 8 logits per lane (ne <= 256); %64 dims = the gathered mul_mm C tiles
+    if (ne < 1l || ne > 256l || k < 1l || k > 16l || k > ne || nfe <= 0l ||
+            (c.dim % 64l) != 0l || (nfe % 64l) != 0l ||
+            ne * ege > 3800000000l ||   // uint32 in-kernel indices (q8 byte view = elements * 34/32)
+            t.router_off < 0l || empty(t.we1_offs) || empty(t.we2_offs) || empty(t.we3_offs)) {
+        return false
+    }
+    if (t.experts_mx4) {
+        // mx4 binds: nibble bytes at off/2 (%4 => off %8), E8M0 at off/32 (%4 => off %128)
+        if ((ege % 32l) != 0l) {
+            return false
+        }
+        for (l in range64(c.n_layers)) {
+            if (t.we1_offs[l] < 0l || (t.we1_offs[l] % 128l) != 0l ||
+                    t.we2_offs[l] < 0l || (t.we2_offs[l] % 128l) != 0l ||
+                    t.we3_offs[l] < 0l || (t.we3_offs[l] % 128l) != 0l) {
+                return false
+            }
+        }
+        return true
+    }
+    for (l in range64(c.n_layers)) {
+        let f1 = moe_fmt_at(t.we1_fmt, l)
+        let f2 = moe_fmt_at(t.we2_fmt, l)
+        let f3 = moe_fmt_at(t.we3_fmt, l)
+        // per-site alignment + reduction dims: superblock kq kernels iterate whole 256-rows,
+        // q51 whole 32-blocks (+ the mul_mm's 64-col output tiles)
+        let sb1 = f1 == KqFmt.k4 || f1 == KqFmt.k5 || f1 == KqFmt.k6
+        let sb3 = f3 == KqFmt.k4 || f3 == KqFmt.k5 || f3 == KqFmt.k6
+        let sb2 = f2 == KqFmt.k4 || f2 == KqFmt.k5 || f2 == KqFmt.k6
+        if (!moe_site_ok(f1, t.we1_offs[l], ege) ||
+                !moe_site_ok(f2, t.we2_offs[l], ege) ||
+                !moe_site_ok(f3, t.we3_offs[l], ege) ||
+                ((sb1 || sb3) && (c.dim % 256l) != 0l) ||
+                (sb2 && (nfe % 256l) != 0l) ||
+                ((f1 == KqFmt.q51 || f3 == KqFmt.q51) && ((c.dim % 32l) != 0l || (nfe % 64l) != 0l)) ||
+                (f2 == KqFmt.q51 && ((nfe % 32l) != 0l || (c.dim % 64l) != 0l))) {
+            return false
+        }
+    }
+    return true
+}
+
+// what each decode path's kernels implement beyond the base llama dense block — grows wave by wave.
+let DECODE_NEEDS_OK = (MetalNeed.neox | MetalNeed.qkv_bias | MetalNeed.qk_norm | MetalNeed.qd_neq_dim |
+    MetalNeed.softcap | MetalNeed.sliding | MetalNeed.pre_post_norm | MetalNeed.geglu |
+    MetalNeed.v_norm | MetalNeed.attn_scale | MetalNeed.out_scale |
+    MetalNeed.sinks | MetalNeed.out_bias | MetalNeed.partial_rope | MetalNeed.q_gated |
+    MetalNeed.ple)
+// q_gated/partial_rope only occur on hybrid models (attn_is_std false), which batch graph-declines;
+// ple (E-series) has no batch arm either — batched steps decline `feature` and fall back per-row
+let BATCH_NEEDS_OK = DECODE_NEEDS_OK & ~MetalNeed.ple   // clear ple explicitly (XOR would re-add it if DECODE ever drops it)
+
+def decode_shape_decline(t : Model; needs_ok : MetalNeed; allow_moe : bool = false; allow_kv_share : bool = false) : MetalDecodeDecline {
+    if (t.quant != QuantMode.q8) {
+        return MetalDecodeDecline.quant_mode
+    }
+    if (!kq_load_gpu_supported(t)) {   // a fmt without a GPU kernel (the q4_0 QAT tier, ...) must not dispatch
+        return MetalDecodeDecline.kquant_native
+    }
+    // non-std graphs decline; MoE (Wave C) + deltanet hybrid (Wave D) serve when their kernels cover it
+    if ((!t.blocks.attn_is_std && !(t.config.hybrid_deltanet && dn_metal_ok(t))) ||
+            (!t.blocks.ffn_is_dense && !(allow_moe && moe_metal_ok(t)))) {
+        return MetalDecodeDecline.graph
+    }
+    if (kernel_backend_needs_repack(active_kernel_backend())) {
+        return MetalDecodeDecline.backend_repack
+    }
+    if (!get_rope_table_mode()) {
+        return MetalDecodeDecline.rope_mode
+    }
+    if (metal_missing_needs(t, needs_ok) != default<MetalNeed>) {
+        return MetalDecodeDecline.feature
+    }
+    let c = t.config
+    let hidden = layer_hidden(t, 0l)
+    // sliding masking lives on the CHUNKED path only — window >= 128 (the single-form depth ceiling's clamp max) guarantees the single form never sees a masked row; decline tighter
+    if (((c.dim % 32l) != 0l || (hidden % 32l) != 0l) ||
+            (c.sliding_window > 0l && c.sliding_window < 128l)) {
+        return MetalDecodeDecline.shape
+    }
+    // per-CLASS: whole simdgroups; red[16] + the epl <= 16 q-register hoist cap the threadgroup width at 512 (gemma4's global class)
+    for (l in range64(c.n_layers)) {
+        if (layer_is_recurrent(c, l)) {   // no KV, no attention tensors — only the FFN uniformity applies
+            if (layer_hidden(t, l) != hidden) {
+                return MetalDecodeDecline.layers
+            }
+            continue
+        }
+        let hs_l = layer_head_size(c, l)
+        if ((hs_l % 32l) != 0l || hs_l > 512l || (layer_kv_dim(c, l) % 32l) != 0l) {
+            return MetalDecodeDecline.shape
+        }
+        // E-series KV sharing: only the single-stream driver has the Q-only arm (allow_kv_share)
+        if ((t.kv_src[l] != l && !(allow_kv_share && kv_share_ok(t, l))) || layer_hidden(t, l) != hidden) {
+            return MetalDecodeDecline.layers
+        }
+        // a missing attn_v (V = the pre-norm K projection) serves — raw copy without v_norm; both encoded (the CPU mm_qkv shapes)
+    }
+    return MetalDecodeDecline.none
+}
+
+// mint-time servability (register_metal_servable): shape/graph/feature gates only — the planar
+// check is a RUNTIME gate. Tied-fp32 classifiers decline: the blob drivers force GPU logits
+// and have no fp32-table GEMV.
+def private metal_model_servable_impl(t : Model) : bool {
+    let cls_fmt = t.config.shared_weights ? t.emb_fmt : t.wcls_fmt
+    // tied-fp32 classifier declines (no fp32-table GEMV); NextN serves — prefill stashes mtp_h + warms the slab
+    if (t.config.shared_weights && !t.cls_q8 && cls_fmt == KqFmt.q8) {
+        return false
+    }
+    return decode_shape_decline(t, DECODE_NEEDS_OK, true, true) == MetalDecodeDecline.none
+}
+
+[init]
+def private register_shape_gates {
+    // pure model shape, registered on EVERY build — a non-Apple converter can bake the metal flavor
+    register_metal_servable(@@metal_model_servable_impl)
+}
diff --git a/modules/dasLLAMA/dasllama/dasllama_transformer.das b/modules/dasLLAMA/dasllama/dasllama_transformer.das
index c7947aa4a7..3346258e5d 100644
--- a/modules/dasLLAMA/dasllama/dasllama_transformer.das
+++ b/modules/dasLLAMA/dasllama/dasllama_transformer.das
@@ -21,5 +21,6 @@ require dasllama/dasllama_arch_qwen35  // nolint:STYLE030 — side-effect requir
 require dasllama/dasllama_arch_gptoss  // nolint:STYLE030 — side-effect require: fires the arch's [init] registration
 require dasllama/dasllama_arch_mistral3  // nolint:STYLE030 — side-effect require: fires the arch's [init] registration
 require dasllama/dasllama_arch_glm4moe  // nolint:STYLE030 — side-effect require: fires the arch's [init] registration
+require dasllama/dasllama_metal_shapes  // nolint:STYLE030 — [init]-only: registers the PORTABLE metal servable predicate (pure model shape) — every build, so a non-Apple converter can bake the metal flavor
 require ?das_metal dasllama/dasllama_metal_prefill  // nolint:STYLE030 — [init]-only: registers prefill override "metal" (the dasMetal GPU-resident path). STRICT guard: Apple builds only; it lives here (not dasllama_common) because it requires the engine back — the umbrella breaks the cycle
 require ?das_metal dasllama/dasllama_metal_llama  // nolint:STYLE030 — [init]-only: registers decode override "metal" (same contract as the prefill line above)

From 25fd4a85d780c5ecb0973f0da8d58aa796dffb51 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 13:42:30 -0700
Subject: [PATCH 26/30] dasllama-convert: -f metal pins the portable backend
 (the metal donor contract)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The blob transform reads ROW-MAJOR planes — under a repack backend the servable
gate correctly declines backend_repack, which is why bare -f metal failed on
BOTH boxes. Portable's layout numbers are box-independent, so the metal identity
converges across boxes with no --config: a PC now mints
v7|q8|portable|s16|q8 mr4 b0 g4|kq 4/4/4/4|q51 mr1|nat 1101|metal.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 utils/dasllama-convert/main.das | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index 8dcc1fd26e..ca28f82374 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -298,6 +298,12 @@ def main() : int {
         to_log(LOG_ERROR, "dasllama-convert: --trim is a vulkan-flavor property (add -f vulkan)\n")
         return 2
     }
+    if (cfg.flavor == Flavor.metal) {
+        // the metal donor contract: the blob transform reads ROW-MAJOR planes, so the mint pins
+        // the portable backend (repack interleaves are unreadable by the drivers). Portable's
+        // layout numbers are box-independent — the metal identity converges across boxes
+        pin_kernel_backend("portable")
+    }
     if (cfg.flavor == Flavor.vulkan) {
         // OFFLINE bake: the walk's accept/refuse arithmetic runs against the config's numbers,
         // the gathers collect, and no Vulkan call is made — no instance, no device, no VRAM

From f3e0534148255ba353a5a922e2b0cbdc9346060c Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 14:09:50 -0700
Subject: [PATCH 27/30] =?UTF-8?q?CI:=20two=20master-level=20lane=20fixes?=
 =?UTF-8?q?=20=E2=80=94=20darwin26=20tensor=20capability=20skip,=20win32?=
 =?UTF-8?q?=20PTY=20cold-start=20timeout?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

tests/metal/test_metal_tensor_ops.das: macOS-26 CI runners pass the SDK/MSL-4.0
probe but their PARAVIRTUAL device cannot lower cooperative tensors — every
pipeline build fails with the "deferred-static-alloca-size" signature (both open
PRs' darwin26 lanes red on it). A signature-gated pre-probe now feints exactly
that case before any allocation; every other compile error still fails loudly,
so real emitter regressions stay visible on Metal-4 hardware.

tests-cpp/small/test_terminal.cpp: the ConPTY probe timed out at 30s waiting for
DASHERD_READY on a loaded windows-32 runner — Windows PowerShell's cold start
(pwsh absent) can exceed it. 120s; the REQUIREs stay, real transport breakage
still fails.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 tests-cpp/small/test_terminal.cpp     |  5 ++++-
 tests/metal/test_metal_tensor_ops.das | 13 +++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/tests-cpp/small/test_terminal.cpp b/tests-cpp/small/test_terminal.cpp
index 238e074119..94474f2ed0 100644
--- a/tests-cpp/small/test_terminal.cpp
+++ b/tests-cpp/small/test_terminal.cpp
@@ -67,7 +67,10 @@ struct PtyProcessGuard {
 
 TEST_CASE("terminal: native PTY is a raw byte transport") {
 #if defined(_WIN32)
-    const int integration_timeout_ms = 30000;
+    // 120s, not 30s: Windows PowerShell's cold start inside ConPTY on a loaded CI runner
+    // (pwsh absent -> powershell.exe, profile-less init) has been observed past 30s — the
+    // timeout is a flake guard, real transport breakage still fails every REQUIRE below
+    const int integration_timeout_ms = 120000;
     PtyProcessOptions options;
     options.columns = 40;
     options.rows = 10;
diff --git a/tests/metal/test_metal_tensor_ops.das b/tests/metal/test_metal_tensor_ops.das
index 25f2c473f4..3755104c59 100644
--- a/tests/metal/test_metal_tensor_ops.das
+++ b/tests/metal/test_metal_tensor_ops.das
@@ -200,6 +200,19 @@ def test_tensor_ops(t : T?) {
                     feint("Metal-4 tensor ops unavailable (needs macOS 26 / MSL 4.0); GPU compare skipped\n")
                     return
                 }
+                // macOS-26 CI runners pass the SDK probe above, but their PARAVIRTUAL device
+                // cannot lower cooperative tensors — pipeline builds fail with the
+                // "deferred-static-alloca-size" signature. That exact signature is a capability
+                // skip; any other compile error still fails loudly in the loop below.
+                var perr0 : string
+                var pso0 = pipeline_from_source(dev, tmm_bf16_msl, tmm_bf16_msl_entry, false, perr0)
+                if (pso0 == null && find(perr0, "deferred-static-alloca-size") >= 0) {
+                    feint("Metal-4 cooperative tensors unsupported by this device (paravirtual runner); GPU compare skipped\n")
+                    return
+                }
+                if (pso0 != null) {
+                    metal_release(pso0)
+                }
                 var queue = metal_new_command_queue(dev)
                 var bxa = buf_upload(dev, oracle.xa)
                 var bwb = buf_upload(dev, oracle.wb)

From fd2b6749d02b2565b8c7c7791e7c2dbcb71ea01a Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 15:51:31 -0700
Subject: [PATCH 28/30] PR round 1: eastl stubs, POSIX dwrite stat contract,
 vulkan-test nolints, Copilot fixes

- DAS_NO_FILEIO: the 7 dwrite/prefetch builtins get their GENERATE_IO_STUB entries
  (build_eastl links registrations without fileio bodies)
- fio_dwrite test: the direct-vs-bounce stat split is platform-dependent (win32 demands
  sector alignment, POSIX align=1 takes band-sized runs direct) - assert conservation
  (direct + bounce == total) plus sub-sector staging instead of the win32-only split
- test_model_image_vulkan: STYLE030 nolints - the body is static_if'd on the vulkan
  module existing, so no-vulkan lint builds see every body-only require as unused
- POST /bake: a malformed JSON body is now 400 instead of silently baking the default slot
- shutdown: leave the bench/bake channel to a still-running worker (channel_remove throws
  on outstanding refs) instead of aborting cleanup
- dwrite header comment: per-platform cache semantics stated honestly (NO_BUFFERING /
  F_NOCACHE / buffered + fadvise DONTNEED)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 .../tests/test_model_image_vulkan.das         | 10 +++++----
 src/builtin/module_builtin_fio.cpp            | 15 ++++++++++---
 tests/fio/fio_dwrite.das                      |  9 ++++----
 utils/dasllama-server/openai_server.das       | 22 ++++++++++++++++---
 4 files changed, 42 insertions(+), 14 deletions(-)

diff --git a/modules/dasLLAMA/tests/test_model_image_vulkan.das b/modules/dasLLAMA/tests/test_model_image_vulkan.das
index 21a6ab6e47..b4b88369a9 100644
--- a/modules/dasLLAMA/tests/test_model_image_vulkan.das
+++ b/modules/dasLLAMA/tests/test_model_image_vulkan.das
@@ -3,12 +3,14 @@ options persistent_heap
 options stack = 131072
 
 require dastest/testing_boost public
-require dasllama/dasllama   // nolint:STYLE029 — umbrella fires each arch [init] registration
-require dasllama/dasllama_image
-require dasllama/dasllama_config
+// STYLE030 nolints: the whole test body is static_if'd on builtin_module_exists(vulkan), so a
+// no-vulkan build compiles it away and every body-only require reads as unused
+require dasllama/dasllama   // nolint:STYLE029,STYLE030 — umbrella fires each arch [init] registration
+require dasllama/dasllama_image   // nolint:STYLE030
+require dasllama/dasllama_config   // nolint:STYLE030
 require dasllama/dasllama_math
 require daslib/jobque_boost
-require daslib/fio
+require daslib/fio   // nolint:STYLE030
 require _model_tier
 
 // The OFFLINE vulkan bake (plan-as-data): the dry tier runs the load walk's accept/refuse
diff --git a/src/builtin/module_builtin_fio.cpp b/src/builtin/module_builtin_fio.cpp
index c38eb555e8..00182e0b91 100644
--- a/src/builtin/module_builtin_fio.cpp
+++ b/src/builtin/module_builtin_fio.cpp
@@ -43,9 +43,11 @@ MAKE_TYPE_FACTORY(clock, das::Time)// use MAKE_TYPE_FACTORY out of namespace. So
 #define getchar_wrapper getchar
 #endif
 
-// The direct sequential writer (dwrite_*): cache-bypassing, strictly-ascending append, used by
-// bulk producers that already know their total size — measured 2060 MB/s vs 275 MB/s for the same
-// volume through buffered fwrite, and it leaves the page cache to whatever the producer is READING.
+// The direct sequential writer (dwrite_*): strictly-ascending append for bulk producers that
+// already know their total size — measured 2060 MB/s vs 275 MB/s for the same volume through
+// buffered fwrite. Cache-bypassing where the platform offers it (FILE_FLAG_NO_BUFFERING on
+// Windows, F_NOCACHE on macOS); the generic POSIX arm is buffered write + posix_fadvise
+// DONTNEED — the page cache is still touched, just released, so the producer's READS keep it.
 // Implemented per-platform at the bottom of this file (same split as the mmap shim above); the
 // handle owns an aligned bounce buffer, so callers append any pointer at any size.
 void * das_dwrite_open ( const char * path, uint64_t total_bytes, uint64_t band_bytes );
@@ -187,6 +189,13 @@ namespace das {
     void * builtin_fmap_open ( const char * name, uint64_t * size, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     void * builtin_fmap_open_rw ( const char * name, uint64_t * size, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     void builtin_fmap_close ( void * data, uint64_t size, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    void * builtin_dwrite_open ( const char * name, uint64_t total_bytes, uint64_t band_bytes, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    bool builtin_dwrite_append ( void * h, void * data, uint64_t bytes, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    void * builtin_dwrite_band ( void * h, uint64_t * avail, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    bool builtin_dwrite_commit ( void * h, uint64_t bytes, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    uint64_t builtin_dwrite_stat ( void * h, int32_t which, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    bool builtin_dwrite_close ( void * h, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
+    bool builtin_prefetch_map ( void * base, uint64_t bytes, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     int64_t builtin_ftell ( const FILE * f, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     int64_t builtin_fseek ( const FILE * f, int64_t offset, int32_t mode, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
     char * builtin_fread ( const FILE * f, Context * context, LineInfoArg * at ) GENERATE_IO_STUB
diff --git a/tests/fio/fio_dwrite.das b/tests/fio/fio_dwrite.das
index c66f29735a..928a996b8c 100644
--- a/tests/fio/fio_dwrite.das
+++ b/tests/fio/fio_dwrite.das
@@ -61,10 +61,11 @@ def test_dwrite(t : T?) {
             total += sz
         }
         t |> success(ok, "every append accepted")
-        // bounce accounting: nothing here was band-sized from an aligned source, so every byte
-        // staged through the band and none went direct
-        t |> equal(uint64(total), unsafe(dwrite_stat(w, 3)), "bounce bytes == appended bytes")
-        t |> equal(0ul, unsafe(dwrite_stat(w, 2)), "no direct bytes on sub-band appends")
+        // stat accounting: the direct-vs-bounce split is platform-dependent (win32 demands
+        // sector-aligned sources, the POSIX arm takes any band-sized run direct) — the portable
+        // contract is conservation, plus the sub-sector pieces must stage through the band
+        t |> equal(uint64(total), unsafe(dwrite_stat(w, 2)) + unsafe(dwrite_stat(w, 3)), "direct + bounce == appended bytes")
+        t |> success(unsafe(dwrite_stat(w, 3)) > 0ul, "sub-sector pieces staged through the band")
         t |> success(unsafe(dwrite_close(w)), "close flushed the tail and truncated")
         verify_file_bytes(t, fname, total, "odd-size appends")
         delete payload
diff --git a/utils/dasllama-server/openai_server.das b/utils/dasllama-server/openai_server.das
index abfbdfa0dd..bc3ca21173 100644
--- a/utils/dasllama-server/openai_server.das
+++ b/utils/dasllama-server/openai_server.das
@@ -655,7 +655,8 @@ def private handle_bake_start(var req : HttpRequest?; var resp : HttpResponse?)
     }
     var model_field = ""
     var jerr = ""
-    var js = read_json(string(req.body), jerr)
+    let body_text = string(req.body)
+    var js = read_json(body_text, jerr)
     defer() {
         unsafe {
             delete js
@@ -663,6 +664,10 @@ def private handle_bake_start(var req : HttpRequest?; var resp : HttpResponse?)
     }
     if (js != null) {
         model_field = js?["model"] ?? ""
+    } elif (!empty(body_text)) {
+        // a malformed body must NOT fall through to the default slot — that would bake the
+        // wrong model on a typo (an empty body legitimately means "the default")
+        return resp |> JSON(error_body("request body is not valid JSON: {jerr}", "invalid_request_error"), http_status.BAD_REQUEST)
     }
     let si = slot_index(model_field)
     if (si < 0) {
@@ -3084,11 +3089,22 @@ def shutdown_server() {
         if (asr_events != null) {
             asr_events |> channel_remove
         }
+        // a still-running worker holds a channel ref, and channel_remove throws on outstanding
+        // refs — leave the channel to the worker (its exit release is safe on the live object;
+        // the worker can't be cancelled, its child process runs minutes) instead of aborting stop
         if (bench_events != null) {
-            bench_events |> channel_remove
+            if (g_bench_state == "running") {
+                to_log(LOG_WARNING, "dasllama-server: shutdown with a bench still running — channel left to the worker\n")
+            } else {
+                bench_events |> channel_remove
+            }
         }
         if (bake_events != null) {
-            bake_events |> channel_remove
+            if (g_bake_state == "running") {
+                to_log(LOG_WARNING, "dasllama-server: shutdown with a bake still running — channel left to the worker\n")
+            } else {
+                bake_events |> channel_remove
+            }
         }
     }
     delete g_bench_log

From af5ee0032790d192ebdcef224b11212ec97b6cf7 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 16:03:53 -0700
Subject: [PATCH 29/30] babysit skill: fixes push immediately - never idle on
 straggler lanes

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 skills/babysit.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/skills/babysit.md b/skills/babysit.md
index 981211a1eb..035abf05ed 100644
--- a/skills/babysit.md
+++ b/skills/babysit.md
@@ -22,6 +22,14 @@ Never merge with an unresolved thread or with Copilot's latest review targeting
 
 ## 1. Watching the PR — the loop
 
+**YOU babysit the build — the user does not babysit YOU.** A ready, verified fix gets
+committed and pushed **immediately**. "Batch fixes into one push" means: fix every *distinct*
+failure currently on the table, then push once — it does **NOT** mean waiting for the rest of
+the matrix to finish. Straggler lanes reproducing an already-fixed failure are zero
+information (the post-push run re-tests everything); idling on them while holding ready fixes
+is the anti-pattern. If two consecutive status updates say "still waiting", you are doing it
+wrong — act.
+
 **Iterate against Copilot (~5 min), not the CI matrix (~30 min).** Copilot's review is a free ruleset check that lands in ~5 minutes; the full CI matrix is free too but takes ~30. So the loop is driven by Copilot and you **never sit through a full matrix between rounds**:
 
 1. Compare the PR's current `headRefOid` with Copilot's latest review `commit_id`.

From dcf834c0c5121f53b7c1614414c94d10bd572154 Mon Sep 17 00:00:00 2001
From: Boris Batkin <bbatkin@gmail.com>
Date: Tue, 28 Jul 2026 16:12:30 -0700
Subject: [PATCH 30/30] dasllama-convert: drop the second
 apply_box_profile_runtime in the streaming branch

It re-read the tune sidecar AFTER the --config override and its fail-closed
identity verify, so a sidecar carrying runtime knobs (backend pin, wscale_f16,
kquant natives) could silently revert a pinned cross-box streamed bake. The
first call (before --config) already applies the sidecar; the config override
must stay last. Surfaced by a Copilot low-confidence remark - verified real.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LcZKEkh1e2z8zPrLX1pKR2
---
 utils/dasllama-convert/main.das | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/utils/dasllama-convert/main.das b/utils/dasllama-convert/main.das
index ca28f82374..63150d6666 100644
--- a/utils/dasllama-convert/main.das
+++ b/utils/dasllama-convert/main.das
@@ -349,7 +349,9 @@ def main() : int {
     // the job que carries the transcode/repack passes; the load spins its own if we do not
     with_job_que() {
         if (cfg.stream && cfg.flavor == Flavor.planar) {
-            apply_box_profile_runtime()
+            // NO apply_box_profile_runtime() here: it already ran before the --config override,
+            // and re-reading the sidecar would revert the config's pinned knobs AFTER the
+            // fail-closed identity verify (silently un-pinning a cross-box streamed bake)
             var mt = Model()
             var jobs : array<FillJob>
             var blk_ran = false