localcode 0.5.25__tar.gz → 0.5.27__tar.gz

{localcode-0.5.25/src/localcode.egg-info → localcode-0.5.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.25
+Version: 0.5.27
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.5.25 → localcode-0.5.27}/llama-cpp-turboquant/ggml/src/ggml-metal/ggml-metal-device.m

@@ -97,6 +97,7 @@ void ggml_metal_pipeline_free(ggml_metal_pipeline_t pipeline) {
 }
 
 int ggml_metal_pipeline_max_theads_per_threadgroup(struct ggml_metal_pipeline_with_params pipeline) {
+    GGML_ASSERT(pipeline.pipeline != NULL && "Metal pipeline unavailable: check kernel compilation diagnostics");
     return pipeline.pipeline->obj.maxTotalThreadsPerThreadgroup;
 }
 

{localcode-0.5.25 → localcode-0.5.27}/llama-cpp-turboquant/ggml/src/ggml-metal/ggml-metal-ops.cpp

@@ -3913,9 +3913,10 @@ int ggml_metal_op_flash_attn_ext(ggml_metal_op_t ctx, int idx) {
         // sparse: the index lists are per query row, so a threadgroup can share KV with Q == 1 only
         auto cfg = use_sparse
                 ? ggml_metal_tuning::fa_vec_baseline_cfg((int) ne00, (int) ne20)
-                : ggml_metal_tuning::fa_vec_pick(
+                : ggml_metal_tuning::fa_vec_pick_kv(
                           props_dev->gpu_family,
                           (int) op->src[1]->type,
+                          (int) op->src[2]->type,
                           (int) ne00, (int) ne20,   // dk, dv (ne00 == dk for FA)
                           ne11, ne01);
 

{localcode-0.5.25 → localcode-0.5.27}/llama-cpp-turboquant/ggml/src/ggml-metal/ggml-metal-tuning.cpp

@@ -1172,4 +1172,12 @@ fa_vec_cfg_t fa_vec_pick(int gpu_family, int dtype, int dk, int dv, int64_t ne11
     return baseline;
 }
 
+fa_vec_cfg_t fa_vec_pick_kv(int gpu_family, int dtype_k, int dtype_v, int dk, int dv, int64_t ne11, int64_t ne01) {
+    const bool turbo = dtype_k == GGML_TYPE_TURBO2_0 || dtype_k == GGML_TYPE_TURBO3_0 || dtype_k == GGML_TYPE_TURBO4_0;
+    if (dtype_k != dtype_v || turbo) {
+        return fa_vec_baseline_cfg(dk, dv);
+    }
+    return fa_vec_pick(gpu_family, dtype_k, dk, dv, ne11, ne01);
+}
+
 }  // namespace ggml_metal_tuning

{localcode-0.5.25 → localcode-0.5.27}/llama-cpp-turboquant/ggml/src/ggml-metal/ggml-metal-tuning.h

@@ -72,4 +72,7 @@ fa_vec_cfg_t fa_vec_baseline_cfg(int dk, int dv);
 // Keyed by Apple GPU family; an untuned family matches no row and gets the baseline.
 fa_vec_cfg_t fa_vec_pick(int gpu_family, int dtype, int dk, int dv, int64_t ne11, int64_t ne01);
 
+// TurboQuant kernels only instantiate the baseline Q/NE variant.
+fa_vec_cfg_t fa_vec_pick_kv(int gpu_family, int dtype_k, int dtype_v, int dk, int dv, int64_t ne11, int64_t ne01);
+
 }  // namespace ggml_metal_tuning

{localcode-0.5.25 → localcode-0.5.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.5.25"
+version = "0.5.27"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.5.25 → localcode-0.5.27}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.5.25"
+    __version__ = "0.5.27"

localcode-0.5.27/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.5.27/src/localcode/bin/localcode-ui
+size: 102460976 bytes
+sha256: 6261bc1125397e699c046d690159a265a2387d1a31c3c8a9cdd333468fedf2c3

{localcode-0.5.25 → localcode-0.5.27}/src/localcode/model_config.py

@@ -128,13 +128,15 @@ BALANCED_RAM_LIFT_MIN_GB = 32
 # ─────────────────────────────────────────────────────────────────────
 #
 # Bytes per KV element by quant type. A MISSING key is deliberate: an unknown
-# type (e.g. "turbo4") means "don't clamp — defer to the validated ceilings",
+# type means "don't clamp — defer to the validated ceilings",
 # never "guess and risk a wrong cap".
 KV_DTYPE_BYTES: dict[str, float] = {
     "f32": 4.0, "f16": 2.0, "bf16": 2.0,
     "q8_0": 1.0625, "q8_1": 1.125,
     "q5_1": 0.875, "q5_0": 0.8125,
     "q4_1": 0.625, "q4_0": 0.5625,
+    # Actual block storage from ggml-common.h, including scale/norm fields.
+    "turbo2": 34 / 128, "turbo3": 50 / 128, "turbo4": 68 / 128,
 }
 
 # RAM-aware KV-fit ceiling reserve + rounding (runtime._kv_aware_ctx_ceiling).

{localcode-0.5.25 → localcode-0.5.27}/src/localcode/runtime.py

@@ -744,20 +744,9 @@ class LocalCodeRuntimeGateway:
     # the GGUF's own attention metadata × the dtype actually launched, then
     # cap ctx so weights + KV-at-full-ctx + headroom fit in unified memory.
     #
-    # CRITICAL design choice — fail OPEN, only tighten when CONFIDENT:
-    # the cap is applied only when the launched KV dtype has a known byte
-    # size (f16/f32/q8_0/…). The TurboQuant path uses compressed KV types
-    # (turbo4-V etc.) whose exact byte size we don't model; for those the
-    # cap is a NO-OP and the existing hardware-validated ceilings
-    # (`_ram_ctx_ceiling`) govern — so this never regresses the tuned
-    # 64K/128K/256K turbo tiers, it only catches the uncompressed-f16
-    # stock-path class that actually OOM'd (cohere/North-Mini).
-
-    # Bytes per KV element by quant type. None-on-miss is deliberate:
-    # an unknown (e.g. "turbo4") type means "don't clamp — defer to the
-    # validated ceilings", never "guess and risk a wrong cap". The table is
-    # the central `model_config.KV_DTYPE_BYTES`; aliased here so the existing
-    # `self._KV_DTYPE_BYTES.get(...)` call sites are unchanged.
+    # Known standard and TurboQuant block sizes are modeled. Unknown formats
+    # or missing attention metadata still defer to the separate RAM ceiling.
+    # Hybrid models are conservatively charged for every reported layer.
     from .model_config import KV_DTYPE_BYTES as _KV_DTYPE_BYTES
 
     def _effective_kv_dtypes(self, model_path: str | None) -> tuple[str, str]:
@@ -769,6 +758,8 @@ class LocalCodeRuntimeGateway:
             return ("f16", "f16")
         k = (getattr(self.config, "kv_cache_type_k", "") or "f16").lower()
         v = (getattr(self.config, "kv_cache_type_v", "") or "f16").lower()
+        if k == "turbo2":
+            k = "q8_0"  # Matches the launcher's value-only TurboQuant2 policy.
         return (k, v)
 
     def _gguf_kv_meta(self, model_path: str | None = None) -> dict | None:
@@ -789,6 +780,7 @@ class LocalCodeRuntimeGateway:
             return cache[path]
         meta: dict | None = None
         found: dict[str, int] = {}
+        architecture = ""
         try:
             if _Path(path).is_file():
                 with open(path, "rb") as f:
@@ -814,13 +806,15 @@ class LocalCodeRuntimeGateway:
 
                         wanted = (
                             ".block_count", ".attention.head_count_kv",
-                            ".attention.head_count", ".attention.key_length",
+                            ".attention.head_count", ".attention.key_length", ".attention.value_length",
                             ".embedding_length", ".nextn_predict_layers",
                         )
                         for _ in range(n_kv):
                             k = _rs()
                             t, = struct.unpack("<I", f.read(4))
                             v = _rv(t)
+                            if k == "general.architecture" and isinstance(v, str):
+                                architecture = v
                             for suf in wanted:
                                 if k.endswith(suf) and isinstance(v, int):
                                     found[suf] = v
@@ -835,6 +829,8 @@ class LocalCodeRuntimeGateway:
                                 "n_layers": n_layers,
                                 "n_kv_heads": n_kv_heads,
                                 "head_dim": head_dim,
+                                "value_head_dim": found.get(".attention.value_length", head_dim),
+                                "architecture": architecture,
                                 # Multi-token-prediction heads shipped inside
                                 # the GGUF (Qwen 3.6+/3.8 `nextn_predict_layers`).
                                 "n_mtp_layers": found.get(".nextn_predict_layers", 0),
@@ -884,19 +880,38 @@ class LocalCodeRuntimeGateway:
         except (TypeError, ValueError):
             return 0
 
-    def _kv_bytes_per_token(self, model_path: str | None = None) -> float | None:
+    def _kv_bytes_per_token(self, model_path: str | None = None, *, dtypes: tuple[str, str] | None = None) -> float | None:
         """KV-cache bytes per token = n_layers × n_kv_heads × head_dim ×
         (bytes_K + bytes_V). Returns None when the metadata or the launched
         KV dtype is unknown (→ caller does not clamp)."""
         meta = self._gguf_kv_meta(model_path)
         if not meta:
             return None
-        kt, vt = self._effective_kv_dtypes(model_path)
+        kt, vt = dtypes or self._effective_kv_dtypes(model_path)
         kb = self._KV_DTYPE_BYTES.get(kt)
         vb = self._KV_DTYPE_BYTES.get(vt)
         if kb is None or vb is None:
-            return None  # compressed/unknown (e.g. turbo) → defer to ceilings
-        return meta["n_layers"] * meta["n_kv_heads"] * meta["head_dim"] * (kb + vb)
+            return None  # unknown storage format → defer to ceilings
+        layers = meta["n_layers"]
+        kd = meta["head_dim"]
+        vd = meta.get("value_head_dim", kd)
+        # TurboQuant stores a complete 128-element rotation group per head.
+        if kt.startswith("turbo"):
+            kd = (kd + 127) // 128 * 128
+        if vt.startswith("turbo"):
+            vd = (vd + 127) // 128 * 128
+        k_bytes = layers * kd * kb
+        v_bytes = layers * vd * vb
+        adaptive = os.environ.get("TURBO_LAYER_ADAPTIVE")
+        if adaptive is None and vt == "turbo2" and layers >= 8:
+            # Backend default: first two and last two value layers use q8.
+            v_bytes += 4 * vd * (self._KV_DTYPE_BYTES["q8_0"] - vb)
+        elif adaptive not in (None, "0"):
+            # User-selected layer policies can widen either cache; bound them
+            # by q8 rather than underestimating an adaptive allocation.
+            k_bytes = max(k_bytes, layers * kd * self._KV_DTYPE_BYTES["q8_0"])
+            v_bytes = max(v_bytes, layers * vd * self._KV_DTYPE_BYTES["q8_0"])
+        return meta["n_kv_heads"] * (k_bytes + v_bytes)
 
     def _model_file_bytes(self, model_path: str | None = None) -> int:
         from pathlib import Path as _Path
@@ -909,7 +924,7 @@ class LocalCodeRuntimeGateway:
         """Largest context whose KV cache fits in RAM beside the weights, with
         headroom for the OS, the app, and compute activations. Returns a large
         sentinel (no clamp) when KV size isn't confidently computable, so the
-        existing validated ceilings govern the turbo-compressed path."""
+        separate RAM ceilings govern the unknown-format path."""
         from .model_config import (
             CTX_NO_CLAMP_SENTINEL, KV_FIT_CTX_MULTIPLE, KV_FIT_MIN_CTX,
             KV_FIT_RESERVE_FRACTION, KV_FIT_RESERVE_GB,
@@ -1061,7 +1076,7 @@ class LocalCodeRuntimeGateway:
         # Universal RAM-aware KV cap on EVERY computed path: no model, present
         # or future, gets a `--ctx-size` whose KV cache can't fit (the OOM
         # never-again guard). No-op when KV size isn't confidently computable
-        # (turbo-compressed KV) — the validated ceilings govern there.
+        # unknown formats — the independent RAM ceiling still applies.
         ram_gb = self._system_ram_gb()
         return min(
             raw, self._ram_ctx_ceiling(ram_gb),

{localcode-0.5.25 → localcode-0.5.27}/src/localcode/ui/server_cmd.py

@@ -84,6 +84,39 @@ def server_command(gguf: str, port: int, alias: str | None = None) -> list[str]:
     mm = mmproj_for(gguf)
     if mm is not None and "--mmproj" not in cmd:
         cmd += ["--mmproj", str(mm)]
+    # Budget every weight file actually passed to the server, including an
+    # explicit user drafter. A 2048-token floor must not override lack of RAM.
+    loaded_paths = {Path(gguf)}
+    for flag in ("--mmproj", "--model-draft"):
+        if flag in cmd:
+            loaded_paths.add(Path(cmd[cmd.index(flag) + 1]))
+    loaded_weights = sum(p.stat().st_size for p in loaded_paths if p.is_file())
+    bpt = g._kv_bytes_per_token(gguf)
+    draft = cmd[cmd.index("--model-draft") + 1] if "--model-draft" in cmd else None
+    spec = cmd[cmd.index("--spec-type") + 1] if "--spec-type" in cmd else ""
+    if draft or spec == "draft-mtp":
+        draft_path = draft or gguf
+        draft_meta = g._gguf_kv_meta(draft_path)
+        if not draft_meta:
+            raise ValueError("Cannot estimate draft-model memory from its GGUF header; disable drafting or select a supported drafter.")
+        # Gemma assistant borrows target KV; ordinary/DFlash contexts own KV.
+        if draft_meta.get("architecture") != "gemma4-assistant":
+            draft_bpt = g._kv_bytes_per_token(draft_path, dtypes=("f16", "f16"))
+            if spec == "draft-mtp":
+                nextn = draft_meta.get("n_mtp_layers", 0)
+                if nextn:
+                    draft_bpt *= nextn / draft_meta["n_layers"]
+                elif not draft:
+                    draft_bpt = 0
+            bpt = (bpt or 0) + (draft_bpt or 0)
+    if bpt:
+        total = ram_gb * 1024**3
+        reserve = max(3 * 1024**3, int(total * 0.15))
+        fit = int((total - loaded_weights - reserve) / bpt) // 2048 * 2048
+        if fit < 2048:
+            raise ValueError("Insufficient RAM for model weights and minimum context; choose a smaller quantization in /models.")
+        ctx_index = cmd.index("--ctx-size") + 1
+        cmd[ctx_index] = str(min(int(cmd[ctx_index]), fit))
     # Prompt warm-up (ui/warmup.py) reads the first turn's token ids back out
     # of a slot save; the flag only enables the endpoint, nothing is written
     # until the supervisor asks.

{localcode-0.5.25 → localcode-0.5.27/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.25
+Version: 0.5.27
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.5.25 → localcode-0.5.27}/src/localcode.egg-info/SOURCES.txt

@@ -1248,6 +1248,7 @@ tests/test_eval_performance.py
 tests/test_eval_suite.py
 tests/test_fresh_install.py
 tests/test_kv_cap.py
+tests/test_metal_kv_selection.py
 tests/test_model_arg_resolution.py
 tests/test_model_config.py
 tests/test_model_verification.py

{localcode-0.5.25 → localcode-0.5.27}/tests/test_comprehensive_model_gate.py

@@ -62,10 +62,31 @@ def test_shutdown_kills_then_waits_after_timeout(tmp_path):
     assert server.proc.wait.call_count == 2
 
 
+@pytest.mark.parametrize("legacy", [False, True])
+def test_dispatch_matrix_ignores_ambient_tensor_disable(monkeypatch, tmp_path, legacy):
+    monkeypatch.setenv("GGML_METAL_TENSOR_DISABLE", "0")
+    proc = Mock()
+    proc.poll.return_value = None
+    captured = {}
+    def launch(*args, **kwargs):
+        captured.update(kwargs["env"])
+        return proc
+    monkeypatch.setattr(gate, "server_command", lambda *a: ["llama-server"])
+    monkeypatch.setattr(gate.subprocess, "Popen", launch)
+    monkeypatch.setattr(gate.Server, "request", lambda *a, **kw: {})
+    with gate.Server(Mock(key="qwen", local_path=tmp_path / "model.gguf"), tmp_path, legacy_metal=legacy):
+        pass
+    assert ("GGML_METAL_TENSOR_DISABLE" in captured) is legacy
+    if legacy:
+        assert captured["GGML_METAL_TENSOR_DISABLE"] == "1"
+
+
 @pytest.mark.parametrize("mutation", ["commit", "binaries", "coverage", "runtime", "decisions", "vision", "turbo"])
 def test_invalid_receipts_cannot_publish_a_promotion(mutation):
     rows = [{"key": key, "turbo4": False, "checks": ["auth", "template", "chat", "tool-loop", "systemone", "decision-control", "runtime", "vision"]} for key in gate.REQUIRED_KEYS]
-    rows.append({"key": "qwen", "turbo4": True, "checks": ["tool-loop"]})
+    rows.extend({"key": "qwen", "turbo4": cache == "turbo4", "cache_v": cache, "legacy_metal": legacy,
+                 "matrix": True, "checks": ["tool-loop", "long-context", "runtime-greeting"]}
+                for cache in ("q8_0", "turbo2", "turbo3", "turbo4") for legacy in (False, True))
     receipt = {"commit": "candidate", "dirty": False, "strict": True, "success": True, "binaries": {"server": "hash"}, "models": rows}
     gate.validate_receipt(receipt, "candidate", {"server": "hash"}, gate.REQUIRED_KEYS)
     if mutation == "commit": receipt["commit"] = "old"

{localcode-0.5.25 → localcode-0.5.27}/tests/test_context_safety.py

@@ -30,3 +30,27 @@ def test_tuned_launcher_context_cannot_bypass_machine_ceiling(source, monkeypatc
     if source == 'environment': monkeypatch.setenv('LOCALCODE_OVERRIDE_NCTX', '98304')
     command = server_cmd.server_command(str(tmp_path / 'Qwen3.6-35B-A3B-UD-IQ2_M.gguf'), 8123)
     assert command[command.index('--ctx-size') + 1] == '73728'
+
+
+@pytest.mark.parametrize("weights_gib,expect_rejection", [(12, True), (10, False)])
+def test_final_memory_budget_includes_explicit_drafter(weights_gib, expect_rejection, monkeypatch, tmp_path):
+    from localcode.ui import server_cmd
+    from localcode.config import AppConfig, UIConfig
+    model = tmp_path / "example-Q4_K_M.gguf"
+    draft = tmp_path / "example-draft.gguf"
+    for path, size in ((model, weights_gib), (draft, 1)):
+        with path.open("wb") as f:
+            f.truncate(size * 1024**3)
+    cfg = AppConfig(runtime=RuntimeConfig(llama_cpp_draft_model=str(draft)), ui=UIConfig())
+    monkeypatch.setattr(server_cmd, 'load_config', lambda: cfg)
+    monkeypatch.setattr(LocalCodeRuntimeGateway, '_system_ram_gb', lambda _: 16)
+    monkeypatch.setattr(LocalCodeRuntimeGateway, '_gguf_kv_meta', lambda *a: {"n_layers":48,"n_kv_heads":8,"head_dim":128})
+    monkeypatch.setenv('LOCALCODE_PROMPT_WARMUP', '0')
+    if expect_rejection:
+        with pytest.raises(ValueError, match="minimum context"):
+            server_cmd.server_command(str(model), 8123)
+    else:
+        cmd = server_cmd.server_command(str(model), 8123)
+        ctx = int(cmd[cmd.index('--ctx-size')+1])
+        # Target uses q8/q8; an ordinary drafter independently uses f16/f16.
+        assert ctx * 48 * 8 * 128 * (2.125 + 4) + (weights_gib + 1 + 3) * 1024**3 <= 16 * 1024**3

{localcode-0.5.25 → localcode-0.5.27}/tests/test_kv_cap.py

@@ -7,7 +7,7 @@ never launch a context whose KV cache won't fit in RAM, for ANY model.
 
 These tests assert the invariant (KV + weights + reserve fits) across every
 RAM tier, AND that the cap defers (no-op) when KV size isn't confidently
-computable — so the validated turbo-compressed ceilings are never regressed.
+computable. Known TurboQuant formats include padding and adaptive layers.
 """
 from __future__ import annotations
 
@@ -40,17 +40,35 @@ def test_kv_bytes_per_token_f16_matches_formula(monkeypatch):
     assert bpt == 48 * 8 * 128 * (2.0 + 2.0)
 
 
-def test_cap_defers_on_unknown_compressed_dtype(monkeypatch):
-    # Turbo-compressed KV (unknown exact bytes) -> bytes/token None -> the cap
-    # is a no-op (large sentinel) so the validated ceilings govern. This is the
-    # no-regression guarantee for the TurboQuant path.
+def test_cap_defers_on_unknown_dtype(monkeypatch):
+    # Unsupported storage formats defer to the independent RAM ceiling.
     gw = _gw()
     monkeypatch.setattr(gw, "_gguf_kv_meta", lambda mp=None: dict(HEAVY_SHAPE))
-    monkeypatch.setattr(gw, "_effective_kv_dtypes", lambda mp: ("q8_0", "turbo4"))
+    monkeypatch.setattr(gw, "_effective_kv_dtypes", lambda mp: ("q8_0", "unknown"))
     assert gw._kv_bytes_per_token() is None
     assert gw._kv_aware_ctx_ceiling(None, 128) >= 1_000_000
 
 
+@pytest.mark.parametrize("cache,block_bytes", [("turbo2",34),("turbo3",50),("turbo4",68)])
+def test_turbo_cache_uses_real_storage_and_distinct_value_width(monkeypatch, cache, block_bytes):
+    monkeypatch.setenv("TURBO_LAYER_ADAPTIVE", "0")
+    gw = _gw()
+    monkeypatch.setattr(gw, "_gguf_kv_meta", lambda mp=None: {**HEAVY_SHAPE, "value_head_dim": 256})
+    monkeypatch.setattr(gw, "_effective_kv_dtypes", lambda mp: ("q8_0", cache))
+    assert gw._kv_bytes_per_token() == 48 * 8 * (128 * 34 / 32 + 256 * block_bytes / 128)
+    monkeypatch.setattr(gw, "_model_file_bytes", lambda mp=None: 12 * 1024**3)
+    cap = gw._kv_aware_ctx_ceiling(None, 16)
+    assert cap * gw._kv_bytes_per_token() + 15 * 1024**3 <= 16 * 1024**3
+
+
+def test_turbo_padding_and_default_boundary_layers_are_budgeted(monkeypatch):
+    monkeypatch.delenv("TURBO_LAYER_ADAPTIVE", raising=False)
+    gw = _gw()
+    monkeypatch.setattr(gw, "_gguf_kv_meta", lambda mp=None: {**HEAVY_SHAPE, "value_head_dim": 192})
+    monkeypatch.setattr(gw, "_effective_kv_dtypes", lambda mp: ("q8_0", "turbo2"))
+    assert gw._kv_bytes_per_token() == 8 * (48 * 128 * 34 / 32 + 44 * 256 * 34 / 128 + 4 * 256 * 34 / 32)
+
+
 def test_kv_cap_invariant_holds_across_all_ram_tiers(monkeypatch):
     # The core invariant: for a heavy f16 model, the capped context's KV cache
     # PLUS weights PLUS reserve must fit in RAM, at EVERY tier.
@@ -104,3 +122,28 @@ def test_explicit_override_bypasses_cap(monkeypatch):
     monkeypatch.setattr(gw, "_kv_aware_ctx_ceiling", lambda mp, ram: 4096)
     # An explicit override is a deliberate value and must not be KV-clamped.
     assert gw._target_num_ctx(num_ctx_override=99999) == 99999
+
+
+def test_cache_storage_table_matches_compiled_backend_blocks(tmp_path):
+    from pathlib import Path
+    import shutil
+    import subprocess
+    from localcode.model_config import KV_DTYPE_BYTES
+    compiler = shutil.which('c++')
+    if not compiler:
+        pytest.skip('C++ compiler unavailable')
+    source = tmp_path / 'storage.cpp'
+    source.write_text(r"""
+#define GGML_COMMON_DECL_CPP
+#include "ggml-common.h"
+#include <cstdio>
+int main() {
+    std::printf("%zu %zu %zu %zu %d %d %d %d", sizeof(block_q8_0),sizeof(block_turbo2_0),sizeof(block_turbo3_0),sizeof(block_turbo4_0),QK8_0,QK_TURBO2,QK_TURBO3,QK_TURBO4);
+}
+""")
+    binary = tmp_path / 'storage'
+    root = Path(__file__).resolve().parents[1]
+    subprocess.run([compiler,'-std=c++17','-I'+str(root/'llama-cpp-turboquant/ggml/src'),str(source),'-o',str(binary)], check=True,capture_output=True,timeout=60)
+    values = [int(x) for x in subprocess.check_output([str(binary)],text=True,timeout=10).split()]
+    for index, dtype in enumerate(('q8_0','turbo2','turbo3','turbo4')):
+        assert KV_DTYPE_BYTES[dtype] == values[index] / values[index+4]

localcode-0.5.27/tests/test_metal_kv_selection.py

@@ -0,0 +1,65 @@
+"""Compile the actual Metal selector and cover its supported cache/shape domains."""
+from pathlib import Path
+import shutil
+import subprocess
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+METAL = ROOT / 'llama-cpp-turboquant/ggml/src/ggml-metal'
+
+
+def test_mixed_and_turbo_kv_select_existing_baseline_variants(tmp_path):
+    compiler = shutil.which('c++') or shutil.which('g++')
+    if not compiler:
+        pytest.skip('C++ compiler unavailable')
+    source = tmp_path / 'selection.cpp'
+    source.write_text(r'''
+#include "ggml-metal-tuning.h"
+#include <cassert>
+#include <cstdio>
+using namespace ggml_metal_tuning;
+int main() {
+    const int types[] = {GGML_TYPE_Q8_0,GGML_TYPE_TURBO2_0,GGML_TYPE_TURBO3_0,GGML_TYPE_TURBO4_0};
+    const int heads[][2] = {{32,32},{64,64},{96,96},{128,128},{192,192},{192,128},{256,256},{320,256},{512,512},{576,512}};
+    int count = 0;
+    for (int family : {7,8,9,10}) for (int key : types) for (int value : types) for (const auto & head : heads)
+    for (int past : {512,1024,4096,8192,16384,65536}) for (int query : {1,2,4,16}) {
+        if (key == GGML_TYPE_Q8_0 && value == GGML_TYPE_Q8_0) continue;
+        const auto expected = fa_vec_baseline_cfg(head[0],head[1]);
+        const auto actual = fa_vec_pick_kv(family,key,value,head[0],head[1],past,query);
+        assert(actual.Q == expected.Q && actual.NE == expected.NE);
+        count++;
+    }
+    // Standard symmetric caches retain their tuned choices.
+    for (int family : {7,8,9,10}) for (int dtype : {GGML_TYPE_F16,GGML_TYPE_BF16,GGML_TYPE_Q4_0,GGML_TYPE_Q4_1,GGML_TYPE_Q5_0,GGML_TYPE_Q5_1,GGML_TYPE_Q8_0})
+    for (int past : {512,1024,4096,8192,16384,65536}) {
+        const auto expected=fa_vec_pick(family,dtype,256,256,past,1);
+        const auto actual=fa_vec_pick_kv(family,dtype,dtype,256,256,past,1);
+        assert(actual.Q == expected.Q && actual.NE == expected.NE);
+    }
+    // A tuning override cannot request uncompiled TurboQuant variants.
+    fa_vec_set_override({4,4});
+    const auto actual=fa_vec_pick_kv(9,GGML_TYPE_Q8_0,GGML_TYPE_TURBO4_0,256,256,8192,1);
+    assert(actual.Q == 1 && actual.NE == fa_vec_baseline_ne(256,256));
+    fa_vec_clear_override();
+    std::printf("%d cache/shape/family cases passed\n",count);
+}
+''')
+    binary = tmp_path / 'selection'
+    subprocess.run([compiler,'-std=c++17','-I'+str(METAL),
+                    '-I'+str(ROOT/'llama-cpp-turboquant/ggml/include'),
+                    str(source),str(METAL/'ggml-metal-tuning.cpp'),'-o',str(binary)],
+                   check=True,capture_output=True,text=True,timeout=90)
+    result = subprocess.check_output([str(binary)],text=True,timeout=30)
+    assert '14400 cache/shape/family cases passed' in result
+    shader = (METAL / 'kernels/fa_vec_turbo.metal').read_text()
+    # The selected names correspond to supplied templates, rather than tuned suffixes.
+    types = ('q8_0','turbo2','turbo3','turbo4')
+    for key in types:
+        for value in types:
+            if key == value == 'q8_0':
+                continue
+            pair = key if key == value else f'k{key}_v{value}'
+            for dk,dv in ((32,32),(64,64),(96,96),(128,128),(192,192),(192,128),(256,256),(320,256),(512,512),(576,512)):
+                assert f'kernel_flash_attn_ext_vec_{pair}_dk{dk}_dv{dv}' in shader

{localcode-0.5.25 → localcode-0.5.27}/tests/test_model_config.py

@@ -39,8 +39,8 @@ def test_kv_dtype_bytes_is_the_central_table():
     from localcode.runtime import LocalCodeRuntimeGateway as GW
     # The class attribute IS the central dict (aliased, not copied).
     assert GW._KV_DTYPE_BYTES is mc.KV_DTYPE_BYTES
-    # A known compressed type is absent → caller defers (no clamp).
-    assert "turbo4" not in mc.KV_DTYPE_BYTES
+    # TurboQuant sizes include all norm fields in the native block layout.
+    assert mc.KV_DTYPE_BYTES["turbo4"] == 68 / 128
     assert mc.KV_DTYPE_BYTES["f16"] == 2.0
 
 

localcode-0.5.25/src/localcode/bin/localcode-ui

@@ -1,4 +0,0 @@
-[diffend] Oversized file quarantined before diffing.
-name: localcode-0.5.25/src/localcode/bin/localcode-ui
-size: 102460976 bytes
-sha256: a2d53215d0f64d948441334403b3124fed40f21d4613bb4a71be80da823c1218