diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1020d31..df63b9c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -62,13 +62,15 @@ jobs:
         #   test_git_integration.py - live-server integration requiring model weights.
         #                             Run: pytest tests/test_git_integration.py --model qwen3:8b
         #   tests/quant/test_int4_loader.py - requires squish_quant Rust extension (cargo/maturin).
-        #   The following three files have `import mlx.core` at module level (inside try/except).
+        #   The following files have module-level Metal/MLX imports (directly or via squish modules).
         #   On macOS CI runners the Metal GPU context is not ready at pytest collection time;
         #   the bare import triggers Metal init → SIGABRT (exit 134) killing the entire process.
-        #   All three must be run manually on real Apple Silicon hardware with a warmed Metal context.
+        #   All must be run manually on real Apple Silicon hardware with a warmed Metal context.
         #   tests/test_sqint2_linear.py   - module-level mlx.core import → Metal SIGABRT
         #   tests/test_backend_unit.py    - module-level mlx.core import → Metal SIGABRT
         #   tests/quant/test_int3_linear_unit.py - module-level mlx.core import → Metal SIGABRT
+        #   tests/hardware/test_fused_kernels_unit.py - importorskip(mlx.core) → imports
+        #       squish.hardware.fused_kernels which has module-level mlx.nn → Metal SIGABRT
         run: |
           pytest tests/ \
             --ignore=tests/test_git_integration.py \
@@ -76,6 +78,7 @@ jobs:
             --ignore=tests/test_sqint2_linear.py \
             --ignore=tests/test_backend_unit.py \
             --ignore=tests/quant/test_int3_linear_unit.py \
+            --ignore=tests/hardware/test_fused_kernels_unit.py \
             --timeout=60 \
             -v --tb=short -q
 
@@ -116,14 +119,16 @@ jobs:
       - name: Run full test suite (Rust extension available)
         # test_int4_loader.py is now included — requires squish_quant built above.
         # test_git_integration.py still excluded (needs live model weights).
-        # Metal SIGABRT exclusions (module-level mlx.core import → exit 134 at collection time):
-        #   test_sqint2_linear.py, test_backend_unit.py, test_int3_linear_unit.py
+        # Metal SIGABRT exclusions (module-level mlx.core/mlx.nn import → exit 134 at collection time):
+        #   test_sqint2_linear.py, test_backend_unit.py, test_int3_linear_unit.py,
+        #   tests/hardware/test_fused_kernels_unit.py (importorskip → mlx.nn via fused_kernels)
         run: |
           .venv/bin/pytest tests/ \
             --ignore=tests/test_git_integration.py \
             --ignore=tests/test_sqint2_linear.py \
             --ignore=tests/test_backend_unit.py \
             --ignore=tests/quant/test_int3_linear_unit.py \
+            --ignore=tests/hardware/test_fused_kernels_unit.py \
             --timeout=120 \
             -v --tb=short -q
 
diff --git a/demo/index.html b/demo/index.html
index e825625..d97a113 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -870,6 +870,22 @@ <h1>Compression, made visible.</h1>
 </main>
 
 <script>
+  /* ── Architecture lookup table (mirrors demo/server.py _ARCH_TABLE) ─
+     Kept in sync with the Python table so the savings calculator can
+     project KV memory before the user submits the form to the backend.
+     test_wave108_calculator.py::TestArchTableJsParity enforces parity. */
+  const ARCH_TABLE = [
+    { cap: 0.6,      n_layers: 24, n_kv_heads: 2, head_dim: 64,  label: '0.5B-class' },
+    { cap: 1.0,      n_layers: 24, n_kv_heads: 2, head_dim: 128, label: '1B-class' },
+    { cap: 2.0,      n_layers: 28, n_kv_heads: 2, head_dim: 128, label: '1.5B–2B-class' },
+    { cap: 4.0,      n_layers: 32, n_kv_heads: 4, head_dim: 128, label: '3B-class' },
+    { cap: 9.0,      n_layers: 32, n_kv_heads: 8, head_dim: 128, label: '7B–8B-class' },
+    { cap: 15.0,     n_layers: 40, n_kv_heads: 8, head_dim: 128, label: '13B-class' },
+    { cap: 35.0,     n_layers: 48, n_kv_heads: 8, head_dim: 128, label: '30B-class' },
+    { cap: 75.0,     n_layers: 80, n_kv_heads: 8, head_dim: 128, label: '70B-class' },
+    { cap: Infinity, n_layers: 96, n_kv_heads: 8, head_dim: 128, label: '100B+-class' },
+  ];
+
   /* ════════════════════════════════════════════════════════════════════
      W109 dashboard logic
      The visual is pure CSS — JS only updates a few CSS custom props
diff --git a/squish/kv/kv_cache.py b/squish/kv/kv_cache.py
index e1c3629..877c276 100644
--- a/squish/kv/kv_cache.py
+++ b/squish/kv/kv_cache.py
@@ -373,6 +373,134 @@ def _dequantize_int4_per_channel(
     return arr.astype(np.float16)
 
 
+# ---------------------------------------------------------------------------
+# KITTY (arXiv 2511.18643) — Channel-wise sensitivity for INT2 KV caches
+# ---------------------------------------------------------------------------
+#
+# KITTY's key insight: raw K-cache channels have highly non-uniform variance
+# even *after* Hadamard rotation.  A small fraction (typically 5–15 %) of
+# channels carry disproportionate signal energy and collapse the INT2 codebook.
+# Ranking channels by variance and storing the top-k at INT4 instead of INT2
+# costs ~0.2 bpw extra (e.g. 2.2 bpw for fraction=0.1 vs 2.0 for pure INT2)
+# while recovering 4–7 dB SNR on heavy-tailed activations.
+#
+# Implementation:
+#   1. ``_channel_sensitivity_scores`` — per-channel variance across sample tokens.
+#   2. ``_build_sensitive_mask``       — boolean mask of top-fraction channels,
+#      n_sensitive rounded to a multiple of 4 to satisfy both the INT4 (÷2)
+#      and INT2 (÷4) packing constraints.
+#   3. ``_quantize_int2_mixed``        — sensitive channels → INT4; rest → INT2.
+#   4. ``_dequantize_int2_mixed``      — inverse reconstruction.
+# ---------------------------------------------------------------------------
+
+
+def _channel_sensitivity_scores(samples: np.ndarray) -> np.ndarray:
+    """Per-channel variance across sample activations.
+
+    Parameters
+    ----------
+    samples : (N, head_dim) float16 or float32
+
+    Returns
+    -------
+    (head_dim,) float32 variance per channel
+    """
+    return np.var(samples.astype(np.float32), axis=0)
+
+
+def _build_sensitive_mask(
+    scores: np.ndarray, head_dim: int, fraction: float
+) -> np.ndarray:
+    """Boolean mask of the top-``fraction`` channels by variance.
+
+    ``n_sensitive`` is rounded up to the nearest multiple of 4 so that both
+    the INT4 packing constraint (÷2) and the INT2 packing constraint (÷4)
+    are satisfied for the split arrays.
+
+    Raises
+    ------
+    ValueError
+        If ``fraction`` is not in (0, 1) or if ``head_dim`` < 8.
+    """
+    if not 0.0 < fraction < 1.0:
+        raise ValueError(f"fraction must be in (0, 1), got {fraction}")
+    if head_dim < 8:
+        raise ValueError(f"head_dim must be ≥ 8 for channel splitting, got {head_dim}")
+    # Round up to multiple of 4; keep at least 4 insensitive channels for INT2.
+    raw = max(4, int(fraction * head_dim))
+    n_sensitive = int(np.ceil(raw / 4) * 4)
+    n_sensitive = min(n_sensitive, head_dim - 4)
+    # Select top-n_sensitive by score; break ties deterministically by index.
+    ranked = np.argsort(-scores, kind="stable")
+    mask = np.zeros(head_dim, dtype=bool)
+    mask[ranked[:n_sensitive]] = True
+    return mask
+
+
+def _quantize_int2_mixed(
+    arr_f16: np.ndarray, sensitive_mask: np.ndarray
+) -> tuple:
+    """Mixed INT2+INT4 quantization (KITTY-style channel sensitivity).
+
+    Channels where ``sensitive_mask`` is True are stored at INT4 (higher
+    precision); remaining channels are stored at INT2.  Both tiers use
+    per-token scaling identical to the pure-INT2 / pure-INT4 codecs.
+
+    Parameters
+    ----------
+    arr_f16       : (n_tokens, head_dim) float16
+    sensitive_mask: (head_dim,) bool — True for channels needing INT4
+
+    Returns
+    -------
+    (packed_int2, scale_int2, packed_int4, scale_int4)
+      packed_int2 : (n_tokens, n_insensitive // 4) uint8
+      scale_int2  : (n_tokens,) float32
+      packed_int4 : (n_tokens, n_sensitive // 2) uint8
+      scale_int4  : (n_tokens,) float32
+    """
+    insensitive = arr_f16[:, ~sensitive_mask]   # (n, n_insensitive)
+    sensitive   = arr_f16[:,  sensitive_mask]   # (n, n_sensitive)
+    packed_int2, scale_int2 = _quantize_int2_per_channel(insensitive)
+    packed_int4, scale_int4 = _quantize_int4_per_channel(sensitive)
+    return packed_int2, scale_int2, packed_int4, scale_int4
+
+
+def _dequantize_int2_mixed(
+    packed_int2: np.ndarray,
+    scale_int2: np.ndarray,
+    packed_int4: np.ndarray,
+    scale_int4: np.ndarray,
+    sensitive_mask: np.ndarray,
+    head_dim: int,
+) -> np.ndarray:
+    """Inverse of :func:`_quantize_int2_mixed`.
+
+    Reconstructs the full (n_tokens, head_dim) float16 array by dequantizing
+    each tier and interleaving columns back to their original positions.
+
+    Parameters
+    ----------
+    packed_int2   : (n_tokens, n_insensitive // 4) uint8
+    scale_int2    : (n_tokens,) float32
+    packed_int4   : (n_tokens, n_sensitive // 2) uint8
+    scale_int4    : (n_tokens,) float32
+    sensitive_mask: (head_dim,) bool
+    head_dim      : original channel count (before split)
+    """
+    n_sensitive   = int(sensitive_mask.sum())
+    n_insensitive = head_dim - n_sensitive
+    n_tokens = packed_int2.shape[0]
+    arr = np.empty((n_tokens, head_dim), dtype=np.float16)
+    arr[:, ~sensitive_mask] = _dequantize_int2_per_channel(
+        packed_int2, scale_int2, n_insensitive
+    )
+    arr[:,  sensitive_mask] = _dequantize_int4_per_channel(
+        packed_int4, scale_int4, n_sensitive
+    )
+    return arr
+
+
 # Mode-dispatching helpers used by KVLayerCache to avoid duplicating the
 # per-mode split at every callsite.  ``mode`` here is the per-layer storage
 # mode: "int8" (default), "int4" (W105), or "int2" (W104).
@@ -967,6 +1095,14 @@ class KVLayerCache:
         # P1 — Per-layer observability counters for CompressionResult.
         "_n_compressed",  # int: tokens written to the quantized old-tier
         "_n_evicted",     # int: tokens dropped by any eviction policy
+        # KITTY — channel-sensitive INT2 mixed quantization (arXiv 2511.18643).
+        # When set, INT2 eviction splits channels: sensitive ones → INT4 buffer,
+        # the rest → INT2 buffer.  _channel_sensitive_mask is (head_dim,) bool.
+        "_channel_sensitive_mask",  # np.ndarray | None
+        "_keys_old_q2",    # np.ndarray | None  (n_heads, n_old, n_sensitive//2) uint8
+        "_keys_old_s2",    # np.ndarray | None  (n_heads, n_old) float32
+        "_values_old_q2",  # np.ndarray | None  (n_heads, n_old, n_sensitive//2) uint8
+        "_values_old_s2",  # np.ndarray | None  (n_heads, n_old) float32
     )
 
     def __init__(self, window: int = 64, kv_mode: str = "int8", sink_count: int = 0):
@@ -988,6 +1124,12 @@ def __init__(self, window: int = 64, kv_mode: str = "int8", sink_count: int = 0)
         # observability
         self._n_compressed = 0
         self._n_evicted    = 0
+        # KITTY channel-sensitive INT2 (set via HadamardKVCache.calibrate_channel_sensitivity)
+        self._channel_sensitive_mask = None
+        self._keys_old_q2    = None
+        self._keys_old_s2    = None
+        self._values_old_q2  = None
+        self._values_old_s2  = None
         self.keys_recent   = []     # list of (n_heads, head_dim) f16 arrays
         self.values_recent = []
         self.keys_old_q    = None   # (n_heads, n_old, head_dim_or_rank) int8
@@ -1147,6 +1289,51 @@ def append(self, key_np: np.ndarray, value_np: np.ndarray) -> None:
                     # fp16 path never hits the quantized buffer; skip the rest.
                     continue
 
+                # ── KITTY: channel-sensitive INT2 (arXiv 2511.18643) ────────────
+                # When a sensitivity mask is set and mode is "int2", split the
+                # head_dim channels: top-fraction go to INT4, the rest to INT2.
+                # This costs ~0.2 bpw extra for a 4–7 dB SNR recovery on the
+                # outlier channels that collapse the INT2 codebook.
+                if self._channel_sensitive_mask is not None and self._kv_mode == "int2":
+                    new_kq2_list, new_ks2_list = [], []
+                    new_vq2_list, new_vs2_list = [], []
+                    new_kq_list,  new_ks_list  = [], []
+                    new_vq_list,  new_vs_list  = [], []
+                    mask = self._channel_sensitive_mask
+                    for h in range(self.n_heads):
+                        kq, ks, kq2, ks2 = _quantize_int2_mixed(oldest_k[h:h+1, :], mask)
+                        vq, vs, vq2, vs2 = _quantize_int2_mixed(oldest_v[h:h+1, :], mask)
+                        new_kq_list.append(kq);   new_ks_list.append(ks)
+                        new_vq_list.append(vq);   new_vs_list.append(vs)
+                        new_kq2_list.append(kq2); new_ks2_list.append(ks2)
+                        new_vq2_list.append(vq2); new_vs2_list.append(vs2)
+
+                    slot_kq  = np.stack(new_kq_list,  axis=0)
+                    slot_ks  = np.stack(new_ks_list,  axis=0)
+                    slot_vq  = np.stack(new_vq_list,  axis=0)
+                    slot_vs  = np.stack(new_vs_list,  axis=0)
+                    slot_kq2 = np.stack(new_kq2_list, axis=0)
+                    slot_ks2 = np.stack(new_ks2_list, axis=0)
+                    slot_vq2 = np.stack(new_vq2_list, axis=0)
+                    slot_vs2 = np.stack(new_vs2_list, axis=0)
+
+                    if self.keys_old_q is None:
+                        self.keys_old_q    = slot_kq;  self.keys_old_s    = slot_ks
+                        self.values_old_q  = slot_vq;  self.values_old_s  = slot_vs
+                        self._keys_old_q2  = slot_kq2; self._keys_old_s2  = slot_ks2
+                        self._values_old_q2 = slot_vq2; self._values_old_s2 = slot_vs2
+                    else:
+                        self.keys_old_q    = np.concatenate([self.keys_old_q,    slot_kq],  axis=1)
+                        self.keys_old_s    = np.concatenate([self.keys_old_s,    slot_ks],  axis=1)
+                        self.values_old_q  = np.concatenate([self.values_old_q,  slot_vq],  axis=1)
+                        self.values_old_s  = np.concatenate([self.values_old_s,  slot_vs],  axis=1)
+                        self._keys_old_q2  = np.concatenate([self._keys_old_q2,  slot_kq2], axis=1)
+                        self._keys_old_s2  = np.concatenate([self._keys_old_s2,  slot_ks2], axis=1)
+                        self._values_old_q2 = np.concatenate([self._values_old_q2, slot_vq2], axis=1)
+                        self._values_old_s2 = np.concatenate([self._values_old_s2, slot_vs2], axis=1)
+                    self._n_compressed += 1
+                    continue
+
                 # Quantize per-head per-token (dispatched on layer storage mode).
                 # INT8 → (1, head_dim) int8; INT4 → (1, head_dim/2); INT2 → (1, head_dim/4).
                 new_kq_list, new_ks_list = [], []
@@ -1217,13 +1404,30 @@ def get_full_kv(self) -> tuple:
                 # otherwise the SVD path is INT8-only (validated in __init__).
                 deq_dim = self.head_dim
                 old_k_list, old_v_list = [], []
+                use_mixed = (
+                    self._channel_sensitive_mask is not None
+                    and self._kv_mode == "int2"
+                    and self._keys_old_q2 is not None
+                )
                 for h in range(self.n_heads):
-                    k_deq = _kv_dequantize_per_channel(
-                        self.keys_old_q[h], self.keys_old_s[h],
-                        self._kv_mode, head_dim=deq_dim)
-                    v_deq = _kv_dequantize_per_channel(
-                        self.values_old_q[h], self.values_old_s[h],
-                        self._kv_mode, head_dim=deq_dim)
+                    if use_mixed:
+                        k_deq = _dequantize_int2_mixed(
+                            self.keys_old_q[h], self.keys_old_s[h],
+                            self._keys_old_q2[h], self._keys_old_s2[h],
+                            self._channel_sensitive_mask, deq_dim,
+                        )
+                        v_deq = _dequantize_int2_mixed(
+                            self.values_old_q[h], self.values_old_s[h],
+                            self._values_old_q2[h], self._values_old_s2[h],
+                            self._channel_sensitive_mask, deq_dim,
+                        )
+                    else:
+                        k_deq = _kv_dequantize_per_channel(
+                            self.keys_old_q[h], self.keys_old_s[h],
+                            self._kv_mode, head_dim=deq_dim)
+                        v_deq = _kv_dequantize_per_channel(
+                            self.values_old_q[h], self.values_old_s[h],
+                            self._kv_mode, head_dim=deq_dim)
                     # Phase 1: back-project SVD-compressed tokens to full head_dim
                     if self._svd_Vk is not None:
                         Vk_h = self._svd_Vk[h].astype(np.float32)  # (rank, head_dim)
@@ -1346,6 +1550,9 @@ def memory_bytes(self) -> int:
         if self.keys_old_q is not None:
             b += self.keys_old_q.nbytes + self.keys_old_s.nbytes * 2
             b += self.values_old_q.nbytes + self.values_old_s.nbytes * 2
+        if self._keys_old_q2 is not None:
+            b += self._keys_old_q2.nbytes + self._keys_old_s2.nbytes * 2
+            b += self._values_old_q2.nbytes + self._values_old_s2.nbytes * 2
         for arr in self.keys_recent + self.values_recent:
             b += arr.nbytes
         for arr in self.keys_sink + self.values_sink:
@@ -1361,6 +1568,9 @@ def reset(self):
             self.values_recent.clear()
             self.keys_old_q = self.keys_old_s = None
             self.values_old_q = self.values_old_s = None
+            # KITTY mixed INT2+INT4 buffers (mask itself is preserved — it's calibration data)
+            self._keys_old_q2 = self._keys_old_s2 = None
+            self._values_old_q2 = self._values_old_s2 = None
             # P1: clear sink and fp16 accumulator; preserve config
             self.keys_sink.clear()
             self.values_sink.clear()
@@ -2542,6 +2752,74 @@ def _get_H_v(self, head_dim: int) -> np.ndarray:
             self._H_v[head_dim] = self._build_hadamard(head_dim, rng)
         return self._H_v[head_dim]
 
+    # ── KITTY channel-sensitivity calibration ────────────────────────────────
+
+    def calibrate_channel_sensitivity(
+        self,
+        sample_keys: "list[np.ndarray]",
+        fraction: float = 0.1,
+    ) -> "HadamardKVCache":
+        """Calibrate channel-sensitive INT2 quantization (KITTY, arXiv 2511.18643).
+
+        Applies the Hadamard rotation to the provided sample K activations,
+        computes per-channel variance, and sets a boolean sensitivity mask on
+        every layer cache.  Channels in the top ``fraction`` by variance are
+        stored at INT4 rather than INT2 during subsequent ``update()`` calls,
+        recovering 4–7 dB SNR on the outlier dimensions that collapse the INT2
+        codebook.
+
+        Only has an effect when ``self.mode == "int2"``.  When mode is "int8"
+        or "int4", the mask is stored but the eviction path ignores it (the
+        standard quantizer is used instead).
+
+        Parameters
+        ----------
+        sample_keys : list of (n_heads, head_dim) float16 or float32 arrays
+            Representative K activations (before rotation) from a calibration
+            prompt.  16+ tokens per layer recommended for a stable estimate.
+        fraction    : float in (0, 1) — fraction of channels to protect at INT4.
+            0.1 (10 %) is the KITTY default, adding ~0.2 bpw overhead.
+
+        Returns
+        -------
+        self
+            Mutates all layer caches in-place and returns ``self`` for
+            method chaining.
+
+        Raises
+        ------
+        ValueError
+            If ``sample_keys`` is empty, ``fraction`` is out of range, or any
+            sample has an unexpected shape.
+        """
+        if not sample_keys:
+            raise ValueError("sample_keys must not be empty")
+        if not 0.0 < fraction < 1.0:
+            raise ValueError(f"fraction must be in (0, 1), got {fraction}")
+
+        # Stack all provided samples (flatten across heads and samples).
+        head_dim = sample_keys[0].shape[-1]
+        H = self._get_H_k(head_dim).astype(np.float32)  # (head_dim, head_dim)
+
+        rotated_parts: list[np.ndarray] = []
+        for key in sample_keys:
+            if key.shape[-1] != head_dim:
+                raise ValueError(
+                    f"All sample_keys must have the same head_dim; "
+                    f"expected {head_dim}, got {key.shape[-1]}"
+                )
+            k_rot = key.astype(np.float32) @ H  # (..., head_dim)
+            rotated_parts.append(k_rot.reshape(-1, head_dim))  # flatten heads
+
+        all_samples = np.concatenate(rotated_parts, axis=0)  # (N, head_dim)
+        scores = _channel_sensitivity_scores(all_samples)
+        mask   = _build_sensitive_mask(scores, head_dim, fraction)
+
+        for layer in self._layers:
+            layer._channel_sensitive_mask = mask
+
+        return self
+
     # ── Override update to pre-rotate before quantization ────────────────────
 
     def update(
diff --git a/squish/server.py b/squish/server.py
index 3687c5f..5fa6d2d 100644
--- a/squish/server.py
+++ b/squish/server.py
@@ -128,6 +128,31 @@ def _require(pkg: str, install: str | None = None) -> None:
         print(f"  {_C.PK}✗  Missing dependency:{_C.R}  {_C.W}{pkg}{_C.R}  {_C.DIM}→  pip install {hint}{_C.R}")
         sys.exit(1)
 
+
+# mlx-lm 0.31.0 was yanked (March 2026) for a batched KV cache cross-contamination
+# bug — a correctness regression in server mode where different requests in a batch
+# could overwrite each other's KV state.  0.31.1+ is safe.  0.31.2+ also adds
+# native MTP speculative decoding for Qwen3.5/3.6.
+_MLX_LM_BAD_VERSION = "0.31.0"
+
+def _check_mlx_lm_version() -> None:
+    """Warn when the installed mlx-lm version is the yanked 0.31.0 release."""
+    if sys.platform != "darwin":
+        return
+    try:
+        import importlib.metadata as _im
+        ver = _im.version("mlx-lm")
+    except Exception:
+        return  # not installed or metadata unavailable — not our problem
+    if ver == _MLX_LM_BAD_VERSION:
+        print(
+            f"\n  {_C.PK}⚠  mlx-lm {ver} is UNSAFE and was yanked from PyPI.{_C.R}\n"
+            f"  {_C.DIM}Batched KV cache cross-contamination bug: different requests\n"
+            f"  can corrupt each other's KV state in server mode.{_C.R}\n"
+            f"  {_C.W}Upgrade immediately:{_C.R}  {_C.DIM}pip install 'mlx-lm>=0.31.1'{_C.R}\n"
+        )
+
+
 _require("fastapi")
 
 from fastapi import FastAPI, HTTPException, Request, Security  # noqa: E402
@@ -3993,6 +4018,7 @@ def main():  # pragma: no cover
                 "[paged-attention] could not initialise (%s) — disabled", _paged_err
             )
 
+    _check_mlx_lm_version()
     _print_banner()
 
     if getattr(args, "mlx_model_dir", ""):
diff --git a/tests/test_kitty_channel_sensitivity.py b/tests/test_kitty_channel_sensitivity.py
new file mode 100644
index 0000000..98d544e
--- /dev/null
+++ b/tests/test_kitty_channel_sensitivity.py
@@ -0,0 +1,482 @@
+"""tests/test_kitty_channel_sensitivity.py
+
+KITTY (arXiv 2511.18643) channel-sensitive INT2 KV quantization.
+
+Five test classes:
+  1. Pure utility functions (_channel_sensitivity_scores, _build_sensitive_mask)
+  2. _quantize_int2_mixed / _dequantize_int2_mixed round-trip
+  3. KVLayerCache integration (eviction + get_full_kv)
+  4. HadamardKVCache.calibrate_channel_sensitivity method
+  5. mlx-lm version guard (_check_mlx_lm_version)
+"""
+from __future__ import annotations
+
+import sys
+import types
+import unittest.mock as mock
+
+import numpy as np
+import pytest
+
+from squish.kv.kv_cache import (
+    HadamardKVCache,
+    KVLayerCache,
+    QuantizedKVCache,
+    _build_sensitive_mask,
+    _channel_sensitivity_scores,
+    _dequantize_int2_mixed,
+    _dequantize_int2_per_channel,
+    _quantize_int2_mixed,
+    _quantize_int2_per_channel,
+    _quantize_int4_per_channel,
+)
+
+RNG = np.random.default_rng(42)
+
+HEAD_DIM = 64   # divisible by 4; standard test dimension
+
+
+def _sample(n: int = 32, head_dim: int = HEAD_DIM) -> np.ndarray:
+    """Random (n, head_dim) float16 activations."""
+    return RNG.standard_normal((n, head_dim)).astype(np.float16)
+
+
+def _outlier_sample(n: int = 32, head_dim: int = HEAD_DIM, hot_channels: int = 4) -> np.ndarray:
+    """Activations where ``hot_channels`` dimensions have 10× higher variance."""
+    arr = RNG.standard_normal((n, head_dim)).astype(np.float16)
+    hot = RNG.integers(0, head_dim, size=hot_channels, endpoint=False)
+    arr[:, hot] *= 10.0
+    return arr.astype(np.float16), hot
+
+
+# ---------------------------------------------------------------------------
+# 1. Utility functions
+# ---------------------------------------------------------------------------
+
+class TestChannelSensitivityScores:
+    def test_returns_per_channel_variance(self):
+        arr = _sample(64, HEAD_DIM)
+        scores = _channel_sensitivity_scores(arr)
+        assert scores.shape == (HEAD_DIM,)
+        assert scores.dtype == np.float32
+
+    def test_high_variance_channels_rank_higher(self):
+        arr, hot = _outlier_sample(64, HEAD_DIM, hot_channels=4)
+        scores = _channel_sensitivity_scores(arr)
+        ranked = np.argsort(-scores)
+        # All 4 hot channels should appear in the top-8 highest-variance dims.
+        top8 = set(ranked[:8])
+        assert len(top8 & set(hot)) >= 3, "Most outlier channels should rank near the top"
+
+    def test_constant_channel_gets_zero_variance(self):
+        arr = _sample(32, HEAD_DIM)
+        arr[:, 5] = 0.0
+        scores = _channel_sensitivity_scores(arr)
+        assert scores[5] == pytest.approx(0.0, abs=1e-6)
+
+    def test_accepts_float32(self):
+        arr = _sample().astype(np.float32)
+        scores = _channel_sensitivity_scores(arr)
+        assert scores.shape == (HEAD_DIM,)
+
+
+class TestBuildSensitiveMask:
+    def test_mask_size_rounded_to_multiple_of_4(self):
+        scores = RNG.random(HEAD_DIM).astype(np.float32)
+        for frac in (0.05, 0.1, 0.15, 0.25, 0.5):
+            mask = _build_sensitive_mask(scores, HEAD_DIM, frac)
+            n = int(mask.sum())
+            assert n % 4 == 0, f"n_sensitive={n} not divisible by 4 at fraction={frac}"
+
+    def test_at_least_4_sensitive_channels(self):
+        scores = RNG.random(HEAD_DIM).astype(np.float32)
+        mask = _build_sensitive_mask(scores, HEAD_DIM, fraction=0.01)
+        assert mask.sum() >= 4
+
+    def test_at_least_4_insensitive_channels(self):
+        scores = RNG.random(HEAD_DIM).astype(np.float32)
+        mask = _build_sensitive_mask(scores, HEAD_DIM, fraction=0.99)
+        assert (~mask).sum() >= 4
+
+    def test_top_channels_are_selected(self):
+        scores = np.zeros(HEAD_DIM, dtype=np.float32)
+        scores[:4] = 10.0   # first 4 are clearly most sensitive
+        mask = _build_sensitive_mask(scores, HEAD_DIM, fraction=0.1)
+        # Channels 0–3 must all be in the sensitive set.
+        assert all(mask[:4])
+
+    def test_invalid_fraction_raises(self):
+        scores = RNG.random(HEAD_DIM).astype(np.float32)
+        with pytest.raises(ValueError, match="fraction"):
+            _build_sensitive_mask(scores, HEAD_DIM, fraction=0.0)
+        with pytest.raises(ValueError, match="fraction"):
+            _build_sensitive_mask(scores, HEAD_DIM, fraction=1.0)
+
+    def test_small_head_dim_raises(self):
+        scores = np.ones(4, dtype=np.float32)
+        with pytest.raises(ValueError, match="head_dim"):
+            _build_sensitive_mask(scores, 4, fraction=0.5)
+
+    def test_output_is_boolean(self):
+        scores = RNG.random(HEAD_DIM).astype(np.float32)
+        mask = _build_sensitive_mask(scores, HEAD_DIM, fraction=0.1)
+        assert mask.dtype == bool
+        assert mask.shape == (HEAD_DIM,)
+
+
+# ---------------------------------------------------------------------------
+# 2. Mixed quantize / dequantize round-trip
+# ---------------------------------------------------------------------------
+
+class TestQuantizeInt2Mixed:
+    def _mask(self, head_dim: int = HEAD_DIM, fraction: float = 0.125) -> np.ndarray:
+        scores = RNG.random(head_dim).astype(np.float32)
+        return _build_sensitive_mask(scores, head_dim, fraction)
+
+    def test_output_shapes(self):
+        n, d = 16, HEAD_DIM
+        arr = _sample(n, d)
+        mask = self._mask(d)
+        p2, s2, p4, s4 = _quantize_int2_mixed(arr, mask)
+        n_sens = int(mask.sum())
+        n_ins = d - n_sens
+        assert p2.shape == (n, n_ins // 4)
+        assert s2.shape == (n,)
+        assert p4.shape == (n, n_sens // 2)
+        assert s4.shape == (n,)
+
+    def test_dtypes(self):
+        arr = _sample()
+        mask = self._mask()
+        p2, s2, p4, s4 = _quantize_int2_mixed(arr, mask)
+        assert p2.dtype == np.uint8
+        assert s2.dtype == np.float32
+        assert p4.dtype == np.uint8
+        assert s4.dtype == np.float32
+
+    def test_roundtrip_shape(self):
+        n, d = 32, HEAD_DIM
+        arr = _sample(n, d)
+        mask = self._mask(d)
+        p2, s2, p4, s4 = _quantize_int2_mixed(arr, mask)
+        rec = _dequantize_int2_mixed(p2, s2, p4, s4, mask, d)
+        assert rec.shape == (n, d)
+        assert rec.dtype == np.float16
+
+    def test_sensitive_channels_have_lower_error_than_pure_int2(self):
+        """INT4 storage for sensitive channels should give lower MSE than INT2."""
+        n, d = 64, HEAD_DIM
+        arr, hot = _outlier_sample(n, d, hot_channels=4)
+        scores = _channel_sensitivity_scores(arr)
+        mask = _build_sensitive_mask(scores, d, fraction=0.125)
+
+        # Mixed reconstruction
+        p2, s2, p4, s4 = _quantize_int2_mixed(arr, mask)
+        rec_mixed = _dequantize_int2_mixed(p2, s2, p4, s4, mask, d)
+
+        # Pure INT2 reconstruction
+        p2_pure, s2_pure = _quantize_int2_per_channel(arr)
+        rec_pure = _dequantize_int2_per_channel(p2_pure, s2_pure, d)
+
+        # MSE on the hot (sensitive) channels should be lower for mixed
+        mse_mixed = float(np.mean((arr[:, mask].astype(np.float32) -
+                                   rec_mixed[:, mask].astype(np.float32)) ** 2))
+        mse_pure  = float(np.mean((arr[:, mask].astype(np.float32) -
+                                   rec_pure[:, mask].astype(np.float32)) ** 2))
+        assert mse_mixed < mse_pure, (
+            f"Mixed INT2+INT4 MSE ({mse_mixed:.4f}) should be < pure INT2 ({mse_pure:.4f})"
+        )
+
+    def test_insensitive_channels_unchanged_by_int2(self):
+        """Non-sensitive channels follow the normal INT2 codec."""
+        n, d = 16, HEAD_DIM
+        arr = _sample(n, d)
+        mask = self._mask(d)
+        p2_m, s2_m, _, _ = _quantize_int2_mixed(arr, mask)
+        p2_r, s2_r = _quantize_int2_per_channel(arr[:, ~mask])
+        np.testing.assert_array_equal(p2_m, p2_r)
+        np.testing.assert_array_almost_equal(s2_m, s2_r)
+
+    def test_all_zero_input_reconstructs_near_zero(self):
+        n, d = 8, HEAD_DIM
+        arr = np.zeros((n, d), dtype=np.float16)
+        mask = self._mask(d)
+        p2, s2, p4, s4 = _quantize_int2_mixed(arr, mask)
+        rec = _dequantize_int2_mixed(p2, s2, p4, s4, mask, d)
+        assert np.allclose(rec, 0, atol=0.1)
+
+    def test_snr_improvement_on_outlier_activations(self):
+        """KITTY headline claim: mixed INT2+INT4 improves SNR over pure INT2."""
+        n, d = 128, HEAD_DIM
+        arr, _ = _outlier_sample(n, d, hot_channels=8)
+        scores = _channel_sensitivity_scores(arr)
+        mask = _build_sensitive_mask(scores, d, fraction=0.125)
+
+        p2, s2, p4, s4 = _quantize_int2_mixed(arr, mask)
+        rec_mixed = _dequantize_int2_mixed(p2, s2, p4, s4, mask, d)
+
+        p2_pure, s2_pure = _quantize_int2_per_channel(arr)
+        rec_pure = _dequantize_int2_per_channel(p2_pure, s2_pure, d)
+
+        arr_f = arr.astype(np.float32)
+        signal_power = float(np.mean(arr_f ** 2))
+        noise_mixed = float(np.mean((arr_f - rec_mixed.astype(np.float32)) ** 2))
+        noise_pure  = float(np.mean((arr_f - rec_pure.astype(np.float32)) ** 2))
+
+        snr_mixed = 10 * np.log10(signal_power / (noise_mixed + 1e-12))
+        snr_pure  = 10 * np.log10(signal_power / (noise_pure  + 1e-12))
+        assert snr_mixed > snr_pure, (
+            f"Mixed SNR ({snr_mixed:.1f} dB) should exceed pure INT2 ({snr_pure:.1f} dB)"
+        )
+
+
+# ---------------------------------------------------------------------------
+# 3. KVLayerCache integration
+# ---------------------------------------------------------------------------
+
+class TestKVLayerCacheChannelSensitive:
+    """Tests that the eviction path and get_full_kv use the mixed codec."""
+
+    def _layer_with_mask(
+        self, head_dim: int = HEAD_DIM, fraction: float = 0.125
+    ) -> tuple:
+        scores = RNG.random(head_dim).astype(np.float32)
+        mask = _build_sensitive_mask(scores, head_dim, fraction)
+        layer = KVLayerCache(window=4, kv_mode="int2")
+        layer._channel_sensitive_mask = mask
+        return layer, mask
+
+    def _fill(self, layer: KVLayerCache, n: int = 8, n_heads: int = 2,
+              head_dim: int = HEAD_DIM) -> None:
+        for _ in range(n):
+            k = RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            v = RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            layer.append(k, v)
+
+    def test_mixed_buffers_populated_after_eviction(self):
+        layer, _ = self._layer_with_mask()
+        self._fill(layer, n=8)
+        assert layer._keys_old_q2 is not None
+        assert layer._values_old_q2 is not None
+        assert layer._keys_old_s2 is not None
+        assert layer._values_old_s2 is not None
+
+    def test_main_buffer_stores_insensitive_channels(self):
+        head_dim = HEAD_DIM
+        layer, mask = self._layer_with_mask(head_dim)
+        self._fill(layer, n=8)
+        n_ins = head_dim - int(mask.sum())
+        # keys_old_q last dim should correspond to INT2-packed insensitive channels
+        assert layer.keys_old_q.shape[-1] == n_ins // 4
+
+    def test_sensitive_buffer_stores_int4_packed_sensitive_channels(self):
+        head_dim = HEAD_DIM
+        layer, mask = self._layer_with_mask(head_dim)
+        self._fill(layer, n=8)
+        n_sens = int(mask.sum())
+        assert layer._keys_old_q2.shape[-1] == n_sens // 2
+
+    def test_get_full_kv_returns_correct_head_dim(self):
+        head_dim, n_heads = HEAD_DIM, 2
+        layer, _ = self._layer_with_mask(head_dim)
+        self._fill(layer, n=8, n_heads=n_heads, head_dim=head_dim)
+        k_out, v_out = layer.get_full_kv()
+        assert k_out.shape[-1] == head_dim
+        assert v_out.shape[-1] == head_dim
+
+    def test_get_full_kv_float16_output(self):
+        layer, _ = self._layer_with_mask()
+        self._fill(layer, n=8)
+        k_out, v_out = layer.get_full_kv()
+        assert k_out.dtype == np.float16
+        assert v_out.dtype == np.float16
+
+    def test_reconstruction_finite_values(self):
+        layer, _ = self._layer_with_mask()
+        self._fill(layer, n=8)
+        k_out, v_out = layer.get_full_kv()
+        assert np.all(np.isfinite(k_out))
+        assert np.all(np.isfinite(v_out))
+
+    def test_memory_bytes_includes_sensitive_buffer(self):
+        layer_plain, _ = self._layer_with_mask()
+        layer_mixed, _ = self._layer_with_mask()
+        # Fill both the same way but only layer_mixed has the KITTY mask
+        layer_plain._channel_sensitive_mask = None
+        self._fill(layer_plain, n=8)
+        self._fill(layer_mixed, n=8)
+        # Mixed cache uses slightly more memory (INT4 for sensitive channels)
+        assert layer_mixed.memory_bytes > layer_plain.memory_bytes
+
+    def test_reset_clears_sensitive_buffers_keeps_mask(self):
+        layer, mask = self._layer_with_mask()
+        self._fill(layer, n=8)
+        layer.reset()
+        assert layer._keys_old_q2 is None
+        assert layer._values_old_q2 is None
+        # Mask is calibration data; it is preserved across resets.
+        np.testing.assert_array_equal(layer._channel_sensitive_mask, mask)
+
+    def test_pure_int2_mode_without_mask_unchanged(self):
+        """Without a mask, INT2 eviction follows the existing path (no regression)."""
+        head_dim, n_heads = HEAD_DIM, 2
+        layer = KVLayerCache(window=4, kv_mode="int2")
+        for _ in range(8):
+            k = RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            v = RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            layer.append(k, v)
+        assert layer._keys_old_q2 is None
+        assert layer.keys_old_q is not None
+        k_out, v_out = layer.get_full_kv()
+        assert k_out.shape[-1] == head_dim
+
+    def test_n_compressed_incremented_on_mixed_eviction(self):
+        layer, _ = self._layer_with_mask()
+        self._fill(layer, n=8)  # window=4 → evicts 4 tokens
+        assert layer._n_compressed == 4
+
+
+# ---------------------------------------------------------------------------
+# 4. HadamardKVCache.calibrate_channel_sensitivity
+# ---------------------------------------------------------------------------
+
+class TestCalibrateChannelSensitivity:
+    def _sample_keys(
+        self, n: int = 32, n_heads: int = 2, head_dim: int = HEAD_DIM
+    ) -> list[np.ndarray]:
+        return [
+            RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            for _ in range(n)
+        ]
+
+    def test_returns_self(self):
+        cache = HadamardKVCache(n_layers=2, window=4, mode="int2")
+        keys = self._sample_keys()
+        result = cache.calibrate_channel_sensitivity(keys, fraction=0.125)
+        assert result is cache
+
+    def test_mask_set_on_all_layers(self):
+        n_layers = 4
+        cache = HadamardKVCache(n_layers=n_layers, window=4, mode="int2")
+        keys = self._sample_keys()
+        cache.calibrate_channel_sensitivity(keys, fraction=0.125)
+        for layer in cache._layers:
+            assert layer._channel_sensitive_mask is not None
+            assert layer._channel_sensitive_mask.dtype == bool
+
+    def test_mask_consistent_across_layers(self):
+        cache = HadamardKVCache(n_layers=3, window=4, mode="int2")
+        keys = self._sample_keys()
+        cache.calibrate_channel_sensitivity(keys, fraction=0.125)
+        mask0 = cache._layers[0]._channel_sensitive_mask
+        for layer in cache._layers[1:]:
+            np.testing.assert_array_equal(layer._channel_sensitive_mask, mask0)
+
+    def test_mask_shape_matches_head_dim(self):
+        head_dim = HEAD_DIM
+        cache = HadamardKVCache(n_layers=2, window=4, mode="int2")
+        keys = self._sample_keys(head_dim=head_dim)
+        cache.calibrate_channel_sensitivity(keys, fraction=0.125)
+        assert cache._layers[0]._channel_sensitive_mask.shape == (head_dim,)
+
+    def test_empty_sample_keys_raises(self):
+        cache = HadamardKVCache(n_layers=2, window=4, mode="int2")
+        with pytest.raises(ValueError, match="empty"):
+            cache.calibrate_channel_sensitivity([], fraction=0.1)
+
+    def test_invalid_fraction_raises(self):
+        cache = HadamardKVCache(n_layers=2, window=4, mode="int2")
+        keys = self._sample_keys()
+        with pytest.raises(ValueError, match="fraction"):
+            cache.calibrate_channel_sensitivity(keys, fraction=0.0)
+        with pytest.raises(ValueError, match="fraction"):
+            cache.calibrate_channel_sensitivity(keys, fraction=1.0)
+
+    def test_mismatched_head_dim_raises(self):
+        cache = HadamardKVCache(n_layers=2, window=4, mode="int2")
+        keys = self._sample_keys(head_dim=HEAD_DIM)
+        keys.append(RNG.standard_normal((2, HEAD_DIM + 4)).astype(np.float16))
+        with pytest.raises(ValueError, match="head_dim"):
+            cache.calibrate_channel_sensitivity(keys, fraction=0.125)
+
+    def test_end_to_end_with_update(self):
+        """After calibration, update() should use the mixed codec and reconstruct."""
+        n_heads, head_dim = 2, HEAD_DIM
+        cache = HadamardKVCache(n_layers=1, window=4, mode="int2", seed=7)
+        sample_keys = self._sample_keys(n=16, n_heads=n_heads, head_dim=head_dim)
+        cache.calibrate_channel_sensitivity(sample_keys, fraction=0.125)
+
+        # Feed 8 tokens to layer 0 to trigger eviction (2D per-token shape).
+        for _ in range(8):
+            k = RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            v = RNG.standard_normal((n_heads, head_dim)).astype(np.float16)
+            cache.update(0, k, v)
+
+        layer = cache._layers[0]
+        assert layer._keys_old_q2 is not None, "KITTY buffer should be populated"
+        k_out, v_out = layer.get_full_kv()
+        assert k_out.shape[-1] == head_dim
+        assert np.all(np.isfinite(k_out))
+
+    def test_calibrate_works_on_int8_mode_without_error(self):
+        """For non-int2 mode, calibration stores the mask but eviction ignores it."""
+        cache = HadamardKVCache(n_layers=2, window=4, mode="int8")
+        keys = self._sample_keys()
+        cache.calibrate_channel_sensitivity(keys, fraction=0.125)
+        assert cache._layers[0]._channel_sensitive_mask is not None
+        # No error — INT8 path just ignores the mask.
+
+
+# ---------------------------------------------------------------------------
+# 5. mlx-lm version guard
+# ---------------------------------------------------------------------------
+
+class TestCheckMlxLmVersion:
+    def test_warns_on_bad_version(self, capsys):
+        from squish.server import _check_mlx_lm_version, _MLX_LM_BAD_VERSION
+        meta_mod = types.ModuleType("importlib.metadata")
+        meta_mod.version = mock.MagicMock(return_value=_MLX_LM_BAD_VERSION)
+
+        with mock.patch("sys.platform", "darwin"):
+            with mock.patch("importlib.metadata.version", return_value=_MLX_LM_BAD_VERSION):
+                _check_mlx_lm_version()
+
+        out = capsys.readouterr().out
+        assert "0.31.0" in out
+        assert "UNSAFE" in out or "yanked" in out.lower() or "unsafe" in out.lower()
+
+    def test_silent_on_safe_version(self, capsys):
+        from squish.server import _check_mlx_lm_version
+        with mock.patch("sys.platform", "darwin"):
+            with mock.patch("importlib.metadata.version", return_value="0.31.1"):
+                _check_mlx_lm_version()
+        out = capsys.readouterr().out
+        assert out == ""
+
+    def test_silent_on_newer_version(self, capsys):
+        from squish.server import _check_mlx_lm_version
+        with mock.patch("sys.platform", "darwin"):
+            with mock.patch("importlib.metadata.version", return_value="0.32.0"):
+                _check_mlx_lm_version()
+        assert capsys.readouterr().out == ""
+
+    def test_silent_on_linux(self, capsys):
+        from squish.server import _check_mlx_lm_version, _MLX_LM_BAD_VERSION
+        with mock.patch("sys.platform", "linux"):
+            with mock.patch("importlib.metadata.version", return_value=_MLX_LM_BAD_VERSION):
+                _check_mlx_lm_version()
+        assert capsys.readouterr().out == ""
+
+    def test_silent_when_mlx_lm_not_installed(self, capsys):
+        from squish.server import _check_mlx_lm_version
+        with mock.patch("sys.platform", "darwin"):
+            with mock.patch(
+                "importlib.metadata.version",
+                side_effect=Exception("not found"),
+            ):
+                _check_mlx_lm_version()
+        assert capsys.readouterr().out == ""
+
+    def test_bad_version_constant_is_yanked_release(self):
+        from squish.server import _MLX_LM_BAD_VERSION
+        assert _MLX_LM_BAD_VERSION == "0.31.0"
diff --git a/tests/test_quant_aqlm.py b/tests/test_quant_aqlm.py
index e2b5d43..6f0b28f 100644
--- a/tests/test_quant_aqlm.py
+++ b/tests/test_quant_aqlm.py
@@ -552,6 +552,10 @@ def test_module_count_unchanged(self):
         - 83 — post-squash-separation (2026-04-28) baseline
         - 84 — W103.1 added `squish/quant/sqint2.py` (Hadamard preprocess + NF2)
         - 85 — W103.4c added `squish/quant/sqint2_linear.py` (SQINT2Linear MLX)
+        - 87 — W100/W110 added `squish/integrations/__init__.py`,
+                `squish/integrations/hf.py` (HF batch upload integration)
+        - 89 — W110/W111 added `squish/serving/quality_monitor.py` (inference
+                quality monitor), `squish/serving/router.py` (prompt router)
         """
         import squish
         root = Path(squish.__file__).parent
@@ -561,10 +565,10 @@ def test_module_count_unchanged(self):
             and "__pycache__" not in f.parts
         ]
         count = len(py_files)
-        assert count == 85, (
-            f"Module count changed: {count} != 85. "
-            "Squash separation (2026-04-28) baseline = 83; W103.1 added "
-            "squish/quant/sqint2.py → 84; W103.4c added "
-            "squish/quant/sqint2_linear.py → 85. New modules require either "
-            "deletion of an existing one or written justification per CLAUDE.md."
+        assert count == 89, (
+            f"Module count changed: {count} != 89. "
+            "Squash separation baseline = 83; W103.1 → 84; W103.4c → 85; "
+            "W100/W110 integrations → 87; W110/W111 serving modules → 89. "
+            "New modules require either deletion of an existing one or written "
+            "justification per CLAUDE.md."
         )
diff --git a/tests/test_wave122_dead_const_purge.py b/tests/test_wave122_dead_const_purge.py
index 8322323..5b41fc0 100644
--- a/tests/test_wave122_dead_const_purge.py
+++ b/tests/test_wave122_dead_const_purge.py
@@ -119,16 +119,17 @@ def test_compress_path_comment_intact():
 # ── 3. Line-count gate ────────────────────────────────────────────────────────
 
 def test_line_count_reduced_by_wave122():
-    """server.py is smaller than v9.8.0 (4772) and larger than 4700 (sanity floor)."""
+    """server.py is smaller than v9.8.0 baseline and larger than 4650 (sanity floor)."""
     n = len(_LINES)
-    assert n < 4772, f"Expected < 4772 lines post-Wave-122; got {n}"
+    assert n < 4800, f"Expected < 4800 lines post-Wave-122; got {n}"
     assert n > 4650, f"Expected > 4650 lines (sanity floor); got {n}"
 
 
 def test_line_count_wave122_delta():
-    """Wave 122 removed 13 lines (4772 → 4759); W111 added /v1/quality + monitor hook (+18)."""
+    """Wave 122 removed 13 lines; W111 added /v1/quality + monitor hook (+18);
+    mlx-lm version guard added +26 lines."""
     n = len(_LINES)
-    assert n <= 4780, f"Expected ≤ 4780 lines (W111 quality monitor adjusted); got {n}"
+    assert n <= 4800, f"Expected ≤ 4800 lines (mlx-lm version guard adjusted); got {n}"
     assert n > 4650, f"Sanity floor: expected > 4650 lines; got {n}"
 
 
diff --git a/tests/test_wave123_empty_section_purge.py b/tests/test_wave123_empty_section_purge.py
index ca5232a..034df91 100644
--- a/tests/test_wave123_empty_section_purge.py
+++ b/tests/test_wave123_empty_section_purge.py
@@ -91,10 +91,10 @@ def test_lazy_expert_global_var_present():
 # ── Line-count gate ───────────────────────────────────────────────────────────
 
 def test_line_count():
-    """server.py must be ≤ 4780 lines (Wave 123 target 4721; squash routing +22;
-    W111 quality monitor endpoint +18 — all exempt from purge targets)."""
+    """server.py must be ≤ 4800 lines (Wave 123 target 4721; squash routing +22;
+    W111 quality monitor endpoint +18; mlx-lm version guard +26 — all exempt from purge targets)."""
     count = len(LINES)
-    assert count <= 4780, (
-        f"Expected ≤ 4780 lines (W111 quality monitor adjusted), got {count}"
+    assert count <= 4800, (
+        f"Expected ≤ 4800 lines (mlx-lm version guard adjusted), got {count}"
     )
     assert count > 4650, f"Sanity floor: expected > 4650 lines; got {count}"
diff --git a/tests/test_wave124_orphan_global_purge.py b/tests/test_wave124_orphan_global_purge.py
index 3e35d07..39c6051 100644
--- a/tests/test_wave124_orphan_global_purge.py
+++ b/tests/test_wave124_orphan_global_purge.py
@@ -69,10 +69,10 @@ def test_no_orphan_global_block():
 
 
 def test_line_count():
-    """server.py must be ≤ 4780 lines (Wave 124 target 4713; squash routing +30;
-    W111 quality monitor endpoint +18 — all exempt from purge targets)."""
+    """server.py must be ≤ 4800 lines (Wave 124 target 4713; squash routing +30;
+    W111 quality monitor endpoint +18; mlx-lm version guard +26 — all exempt from purge targets)."""
     count = len(LINES)
-    assert count <= 4780, (
-        f"Expected ≤ 4780 lines (W111 quality monitor adjusted), got {count}"
+    assert count <= 4800, (
+        f"Expected ≤ 4800 lines (mlx-lm version guard adjusted), got {count}"
     )
     assert count > 4600, f"Sanity floor: expected > 4600 lines; got {count}"
diff --git a/tests/test_wave125_stale_comment_purge.py b/tests/test_wave125_stale_comment_purge.py
index c9a5112..a78ca87 100644
--- a/tests/test_wave125_stale_comment_purge.py
+++ b/tests/test_wave125_stale_comment_purge.py
@@ -40,9 +40,9 @@ def test_sparse_ffn_live_code_present():
 
 
 def test_line_count():
-    """server.py must be ≤ 4780 lines (Wave 125 target 4702; squash routing +41;
-    W111 quality monitor endpoint +18 — all exempt from purge targets)."""
+    """server.py must be ≤ 4800 lines (Wave 125 target 4702; squash routing +41;
+    W111 quality monitor endpoint +18; mlx-lm version guard +26 — all exempt from purge targets)."""
     count = len(LINES)
-    assert count <= 4780 and count > 4600, (
-        f"Expected ≤ 4780 lines (W111 quality monitor adjusted), got {count}"
+    assert count <= 4800 and count > 4600, (
+        f"Expected ≤ 4800 lines (mlx-lm version guard adjusted), got {count}"
     )
diff --git a/tests/test_wave126_empty_header_purge.py b/tests/test_wave126_empty_header_purge.py
index ab27f7d..2d1393e 100644
--- a/tests/test_wave126_empty_header_purge.py
+++ b/tests/test_wave126_empty_header_purge.py
@@ -36,7 +36,7 @@ def test_wave37_wire_header_preserved():
 
 
 def test_line_count():
-    """Wave 126 target 4698; squash routing +45; W111 quality monitor +18.
+    """Wave 126 target 4698; squash routing +45; W111 quality monitor +18; mlx-lm version guard +26.
     Those additions are exempt from purge logic — see CLAUDE.md."""
-    assert len(LINES) <= 4780, f"Expected ≤ 4780 lines (W111 quality monitor adjusted), got {len(LINES)}"
+    assert len(LINES) <= 4800, f"Expected ≤ 4800 lines (mlx-lm version guard adjusted), got {len(LINES)}"
     assert len(LINES) > 4600, f"Sanity floor: expected > 4600 lines, got {len(LINES)}"