mtplx 2.12.2__tar.gz → 2.12.3__tar.gz

{mtplx-2.12.2 → mtplx-2.12.3}/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable user-facing changes to MTPLX. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/).
 
+## [2.12.3] - 2026-11-06
+
+### Fixed
+
+- **Flash-Next follow-up turns reuse the conversation again** (#591, #616, #649). 2.12.2 saved a Flash-Next conversation without the draft head's history whenever it kept no live copy of it (OpenCode's tool turns, API clients that send no session id, a turn saved after it ended). The next turn could not resume from it and read the whole prompt again, reported as `new_session`. With OpenCode 1.19.5 on Flash-Next Bare Speed (M5 Max, October 30), 2.12.2 served 0 of 19 follow-up requests from the cache, with the first token in 3.0 to 9.9 s, and 2.12.3 served 30 of 30 and 98.4% of all prompt tokens, with a median first token of 0.18 s. With OpenCode 2.2.5 on Flash-Next Optimized Speed (November 4), 97.2% of prompt tokens came from the cache instead of none. Pi 1.4.0 was not affected (97.8% and 96.7%). A restore that finds an entry without the history now reports `no_snapshot_coverage`.
+- **A new conversation about the same document resumes inside the earlier prompt** (#649, #637 by @jvmenen). The turn's final save keeps the restore points recorded while its prompt was read.
+- **Plain Flash-Next chat with the SSD cache off resumes at the previous turn** (#291, reported by @nol166). Without the SSD cache, the point at the end of a plain chat prompt was saved only when tools were declared, so a client that sends answers back without their reasoning resumed every follow-up at the first turn's prompt. Flash-Next now saves it for plain chat too, without copying the conversation. Other models keep the old rule.
+- **A retry or regenerate resumes from the saved prompt** (#661 by @a3rosol). The saved answer keeps the prompt's last logits (about 1 MB). A retry of a 16,000-token prompt read it again in 23.5 s on an M1 Ultra in the report.
+- **Long sessions without a session id keep their cache** (#624). A difference inside an answer MTPLX generated no longer loses the session once the conversation grows (35,440 of 163,242 tokens restored and 95.6 s to the first token, in the report).
+- **`MTPLX_MTP_HISTORY_POLICY=cycle` keeps the prompt cache** (#400, #422). Each turn was saved under a different label from the one the next turn looked for (166 s to the first token at 76,000 tokens on an M2 Ultra, from #422).
+- **Plain decoding resumes each conversation from the previous turn.** With `--generation-mode ar`, `--no-mtp`, `--stock-ar` or `--no-load-mtp`, each prompt is saved before the answer, as with speculative decoding, instead of only after turns that added 1,024 tokens.
+- **Flash-Next no longer fails with an HTTP 500 after a compaction** (#592, #605): `QSA pooled hold N rows; resizing to M would cut them`, on turns that resumed from the start of a longer saved conversation, and on their instant retries. The attention index's block count is taken from the restored conversation (#650 by @goodbadwolf), and a resize keeps only the blocks the conversation covers (adapted from #657 by @transcendence-x). A replay of #605 now resizes 122,880 bytes and runs on the compiled verifier.
+- **A Flash-Next turn restored from the SSD cache no longer selects attention blocks from another conversation** (#635). In a replay, 25 of 64 new tokens got a different attention output on 2.12.2. A restored turn now decodes the same tokens and final logits as a cold start. Flash-Next conversations saved to the SSD cache by 2.11.2 to 2.12.2 are no longer used, because they may hold another conversation's blocks, so each reads its prompt once after updating, and the cache's normal eviction reclaims the old entries.
+- **SSD restores run on the request's own cache layout** (#608 by @jvmenen, #668 by @CocoaBeans). On an M5 Pro with 64 GB and Qwen 3.8 27B Optimized Speed, a 62,000-token exact restore went from 50.1 to 303.2 tok/s prompt, 15.0 to 23.7 tok/s decode and 124.7 to 23.4 s to the first token (@CocoaBeans's measurement).
+- **A conversation moved to the SSD cache restores its own state** (#609 by @jvmenen) instead of only a system prompt it shares with a conversation still in memory (143 to 146 s at 50,000 tokens in the report, or a 507). Candidates it does not use are released before its prompt is read.
+- **Partial SSD restores work on paged and tail-owned caches** (#655, fixed in #656 by @Phydra11). They failed with `TypeError: int() ... NoneType`.
+- **Flash-Next loads without its draft head again** with `--generation-mode ar --no-load-mtp` and with `--stock-ar` (#400).
+- **A server at Metal's 499,000-buffer limit keeps serving** (#640). The guard releases idle conversations' saved state, and the 507 says the limit is a buffer count and when a restart is needed.
+- **Claude Code.** Sessions follow Claude Code's session header and each subagent gets its own session (#606 by @jvmenen). Side requests no longer replace the conversation's cached turn, and `X-Claude-Code-Request-Class` is read when sent. `/effort low`, `medium` and `max` apply, while the default `high` keeps the server's default (#634 by @goodbadwolf). The auto-mode safety check runs without thinking (#670 by @phaedrus1992, for #669).
+- **Codex.** `reasoning_summary_delivery` is accepted (#658), a preamble with its tool call is one assistant turn (#603), and the Responses stream sends a status event every 5 seconds while a long prompt is read, so Codex's idle timer no longer ends the turn before the first token (#680 by @SuperMarioYL).
+- **OpenCode 2.x.** Title requests are answered without the model, so they no longer get your turn refused with "already in flight" or replace its cache. The 32,000-token default OpenCode 2.x sends is dropped, as the plugin did before; `--max-response-tokens` still applies. The app installs the same OpenCode plugin package as `mtplx`, with OpenCode 2.x's entry.
+- **Clients can keep tool-call markup on requests without tools** (#674, #675 by @energypantry): `MTPLX_KEEP_ORPHAN_TOOL_MARKUP=on` for the whole server, or the `x-mtplx-keep-tool-markup: on` header or the `"keep_orphan_tool_markup": true` field per request.
+- **OpenCode**: the tool-call example shows parameter syntax when any tool has parameters (#584).
+- **An answer that ends inside an unclosed reasoning block is returned when tools are declared** (#583, #588 by @jvmenen).
+- **The request log says what really happened to a request** (#652, #631, #600, #617 by @jvmenen): cancelled, nothing to reuse and why, refused with its reason, and how long it waited for other work.
+- **Paste or drop images into the web chat** (#601).
+- **`--scheduler-mode mtp_batch` says it serves the Qwen 3.6 35B-A3B packs only**, and which flags to drop.
+- **DeepSeek MTP packs skip the output head when only the last row or no logits are needed** (#636 by @sypsyp97).
+- **The opt-in incremental SSD encode no longer mistakes a block with flipped signs for the old one** (#596 by @jvmenen).
+- **Structured output names why llguidance cannot load**, in the refusal and in `mtplx doctor` (#643).
+- **Smart fan mode no longer leaves a watchdog process per ramp** (#602).
+- **`mtplx forge build` works with a relative `--out`** (#627, diagnosed by @Starefossen).
+- **Gemma 4 loaded without its draft model runs** (#632 by @jvmenen).
+- **`lock_wait_time_s` includes the serial queue wait** (#576 by @jvmenen).
+- **Tests ignore the shell's `MTPLX_` settings and never open the real session cache** (#644 by @jvmenen).
+
+### Added
+
+- **`--trust-network`**: with `--no-auth`, serves without an API key on a non-localhost bind (#491). Either flag alone keeps the old behavior.
+- **The dashboard's Cache tab shows what RAM and the SSD hold** (#622), the decode chart plots live samples over five minutes and shows the value under the cursor (#598, #626), and the verify waterfall is easier to read (#590), by @jvmenen.
+- **The Live tab says when macOS slows the GPU because of heat**, in all 13 languages.
+
+### Changed
+
+- **The app opens the Settings popover, the launch overlay and the model picker in one 0.2 s step**, asks the engine for a dashboard snapshot every 500 ms instead of every 100 ms during requests (once a second when its window is hidden), and draws the gauge on the GPU: 0.22 of a CPU core instead of 1.22 during a Flash-Next answer on an M5 Max.
+- **Dependencies.** certifi 2026.10.18 in the lockfile (#672), and newer GitHub Actions in the release workflows (#612, #613, #664, #665), by @dependabot.
+
 ## [2.12.2] - 2026-10-03
 
 ### Fixed

{mtplx-2.12.2 → mtplx-2.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtplx
-Version: 2.12.2
+Version: 2.12.3
 Summary: Native MTP speculative decoding for Qwen3-Next on Apple Silicon.
 Author-email: Youssof Altoukhi <business@youssofal.com>
 License-Expression: Apache-2.0

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/attention_split.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import inspect
 import os
 from typing import Any
 
@@ -806,6 +807,21 @@ def _install_split_attention_hook(attn: Any) -> bool:
     return True
 
 
+def _takes_shared_kv(attn: Any) -> bool:
+    """True for attention that threads KV through ``shared_kv``/``offset``.
+
+    Gemma 4's ``Attention.__call__`` takes those keywords and returns
+    ``(out, (keys, values), offset)``; the generic hook's signature and return
+    value do not match. The Gemma 4 pair path runs its own attention and never
+    installs the hook, so a plain Gemma 4 load must be left alone as well.
+    """
+
+    try:
+        return "shared_kv" in inspect.signature(type(attn).__call__).parameters
+    except (TypeError, ValueError):
+        return False
+
+
 def _full_attention_layers(model: Any):
     text_model = getattr(model, "language_model", model)
     inner = getattr(text_model, "model", text_model)
@@ -821,6 +837,8 @@ def _full_attention_layers(model: Any):
         # semantics.
         if getattr(attn, "_mtplx_generic_sdpa_rewrites_unsupported", False):
             continue
+        if _takes_shared_kv(attn):
+            continue
         yield attn
 
 

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/backends/gemma4_assistant.py

@@ -3171,16 +3171,24 @@ def _restore_or_prefill_gemma4_prompt(
         if callable(candidates) and callable(restore_prefix):
             from mtplx.session_bank import _restore_identity_compatible
 
-            for entry, matched in candidates(
-                prompt_ids,
-                model_path=str(runtime.model_path),
-                mtp_enabled=bool(runtime.mtp_enabled),
-                hidden_variant="gemma4_pre_norm",
-                template_hash=session_template_hash,
-                mtp_history_policy=GEMMA4_SESSION_STATE_POLICY,
-                draft_head_identity=session_draft_head_identity,
-                policy_fingerprint=session_policy_fingerprint,
-            ):
+            # Taken off the list as each one is tried, so a refused candidate
+            # (the SSD tier decodes its row before this lane sees it) is not
+            # held through a later candidate's tail forward or the cold
+            # prefill below; the untried rest go before that forward too.
+            pending = list(
+                candidates(
+                    prompt_ids,
+                    model_path=str(runtime.model_path),
+                    mtp_enabled=bool(runtime.mtp_enabled),
+                    hidden_variant="gemma4_pre_norm",
+                    template_hash=session_template_hash,
+                    mtp_history_policy=GEMMA4_SESSION_STATE_POLICY,
+                    draft_head_identity=session_draft_head_identity,
+                    policy_fingerprint=session_policy_fingerprint,
+                )
+            )
+            while pending:
+                entry, matched = pending.pop(0)
                 matched = int(matched)
                 if (
                     matched < 2
@@ -3227,9 +3235,20 @@ def _restore_or_prefill_gemma4_prompt(
                     prefix_restore = cache = _history = boundary_hidden = None
                     continue
                 seed = restore_point - 1
+                pending.clear()
+                # A candidate the SSD tier decoded is this request's own copy,
+                # already cloned into ``cache``; a RAM entry stays with the
+                # bank, which keeps its hits.
+                banked = (
+                    None
+                    if getattr(entry, "cache_source", "ram") == "ssd"
+                    else entry
+                )
+                entry = None
                 output, _suffix_elapsed = forward(list(prompt_ids[seed:]), cache)
-                entry.hits += 1
-                entry.last_access_s = time.time()
+                if banked is not None:
+                    banked.hits += 1
+                    banked.last_access_s = time.time()
                 return Gemma4PromptState(
                     cache=cache,
                     logits=output.logits[:, -1, :],
@@ -3243,6 +3262,7 @@ def _restore_or_prefill_gemma4_prompt(
                     cache_miss_reason=None,
                     restore_mode=f"block_prefix_{storage_mode}",
                 )
+            entry = None
         return cold_prefill(getattr(session_bank, "last_miss_reason", None))
 
     suffix = list(prompt_ids[restored.entry.prefix_len :])

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/cache_bank/codec.py

@@ -103,6 +103,15 @@ INCREMENTAL_WHOLE_TENSOR_MIN_BYTES = 1024 * 1024
 _UINT_VIEW_BY_ITEMSIZE: dict[int, Any] = {1: mx.uint8, 2: mx.uint16, 4: mx.uint32}
 
 
+def _mix32(bits: Any) -> Any:
+    """Per-element uint32 mixer (lowbias32 variant; uint32 ops wrap in MLX)."""
+    h = bits ^ (bits >> mx.array(16, dtype=mx.uint32))
+    h = h * mx.array(0x7FEB352D, dtype=mx.uint32)
+    h = h ^ (h >> mx.array(15, dtype=mx.uint32))
+    h = h * mx.array(0x846CA68B, dtype=mx.uint32)
+    return h ^ (h >> mx.array(16, dtype=mx.uint32))
+
+
 def content_fingerprints(value: Any, *, rows: int | None = None) -> list[int] | None:
     """64-bit content fingerprints of a tensor, computed on the GPU.
 
@@ -111,9 +120,11 @@ def content_fingerprints(value: Any, *, rows: int | None = None) -> list[int] |
     without it, one fingerprint for the whole tensor. The fingerprint reads
     the raw bits (an unsigned view, so -0.0/+0.0 and NaN payloads differ)
     and folds them into two position-weighted sums modulo 2**32: one linear,
-    one over the squared bits. Integer arithmetic makes it exact and
-    order-independent; a single changed element always changes the linear
-    sum (odd weights). Returns None for dtypes without a same-size unsigned
+    one over the bits after a non-linear 32-bit mixer. Integer arithmetic
+    makes it exact and order-independent; a single changed element always
+    changes the linear sum (odd weights). The mixer replaces an earlier
+    squared-bits term that was blind to sign flips (b*b == (-b)*(-b) for the
+    top bit), so an even number of float32 sign flips collided. Returns None for dtypes without a same-size unsigned
     view (e.g. 8-byte types), which then take the normal copy path.
     """
     view_dtype = _UINT_VIEW_BY_ITEMSIZE.get(int(value.dtype.size))
@@ -142,7 +153,7 @@ def content_fingerprints(value: Any, *, rows: int | None = None) -> list[int] |
     weight_b = (index * mx.array(0x85EBCA6B, dtype=mx.uint32)
                 + mx.array(0xC2B2AE35, dtype=mx.uint32)) | mx.array(1, dtype=mx.uint32)
     sum_a = mx.sum(bits * weight_a, axis=1)
-    sum_b = mx.sum((bits * bits) * weight_b, axis=1)
+    sum_b = mx.sum(_mix32(bits) * weight_b, axis=1)
     mx.eval(sum_a, sum_b)
     return [
         ((int(a) & 0xFFFFFFFF) << 32) | (int(b) & 0xFFFFFFFF)
@@ -812,17 +823,22 @@ def _spec_items(spec: Any) -> list[Any]:
 
 
 def _none_tree_like(spec: Any) -> Any:
-    """Return a shape-compatible tree whose leaves are ``None``.
+    """Return a positional tree of ``None``: one ``None`` per top-level item.
 
     CacheSnapshot's outer state/meta tuples are positional.  Keeping that
-    shape lets ``restore_cache`` skip every original full-prefix meta state.
+    shape lets ``restore_cache`` skip every original full-prefix meta state,
+    but it only skips an item that *is* ``None``.  The items must therefore
+    not be recursed into: a layer whose meta state is a tuple (the paged KV
+    cache's ``(block_size, num_blocks, offset)``) would otherwise become
+    ``(None, None, None)``, not be skipped, and crash ``int(value[2])`` in
+    its ``meta_state`` setter (TypeError on every partial-prefix SSD restore).
     """
 
     kind = spec.get("kind") if isinstance(spec, dict) else None
     if kind == "tuple":
-        return tuple(_none_tree_like(item) for item in spec.get("items") or [])
+        return tuple(None for _ in spec.get("items") or [])
     if kind == "list":
-        return [_none_tree_like(item) for item in spec.get("items") or []]
+        return [None for _ in spec.get("items") or []]
     return None
 
 

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/cache_bank/cold_tier.py

@@ -374,6 +374,7 @@ class SessionBankColdTier:
     # the pre-shadow call shape.
     SUPPORTS_RESIDENT_DUPLICATE_SHADOW = True
     SUPPORTS_MIN_USEFUL_MATCHED_TOKENS = True
+    SUPPORTS_MIN_RESTORE_POINT = True
 
     def __init__(
         self,
@@ -1118,6 +1119,66 @@ class SessionBankColdTier:
         self._set_last_miss("ssd_prefix_miss")
         return None
 
+    def exact_prefix_len(
+        self,
+        token_ids: list[int] | tuple[int, ...],
+        *,
+        model_path: str,
+        mtp_enabled: bool,
+        hidden_variant: str | None = None,
+        template_hash: str | None = None,
+        mtp_history_policy: str | None = None,
+        draft_head_identity: str | None = None,
+        policy_fingerprint: str | None = None,
+    ) -> int:
+        """Length of the longest stored entry that is a whole prefix of
+        ``token_ids``, read from the manifest alone (no tensor is read).
+
+        The rows are the ones ``lookup`` would try, under the row gates
+        ``_restore_row`` applies before it reads a tensor, and without the
+        rows ``SessionBank._restore_cold`` refuses once read: a request that
+        names a hidden variant needs the entry's final logits and hidden
+        (``ssd_missing_mtp_generation_state``), which a row carries exactly
+        when the bank stamped ``mtp_full`` on it. A probe, not a lookup: no
+        counter and no miss reason change.
+        """
+        if self.mode in {"off", "write-only"}:
+            return 0
+        tokens = tuple(int(token) for token in token_ids)
+        if not tokens:
+            return 0
+        try:
+            rows = self._candidate_rows(
+                tokens,
+                model_path=model_path,
+                mtp_enabled=mtp_enabled,
+                hidden_variant=hidden_variant,
+                template_hash=template_hash,
+                mtp_history_policy=mtp_history_policy,
+                draft_head_identity=draft_head_identity,
+                policy_fingerprint=policy_fingerprint,
+            )
+            for row in rows:
+                if int(row["format_version"]) != COLD_TIER_FORMAT_VERSION:
+                    continue
+                epoch = row["mtp_snapshot_epoch"]
+                if epoch is not None and int(epoch) != int(row["snapshot_epoch"]):
+                    continue
+                if hidden_variant is not None and not _row_carries_generation_state(row):
+                    continue
+                prefix = tuple(
+                    int(token) for token in json.loads(str(row["token_ids_json"]))
+                )
+                if prefix and tokens[: len(prefix)] == prefix:
+                    return len(prefix)
+        except Exception as exc:
+            logger.warning(
+                "SessionBank SSD exact-prefix probe failed: %s: %s",
+                type(exc).__name__,
+                exc,
+            )
+        return 0
+
     def lookup_prefix_boundary(
         self,
         token_ids: list[int] | tuple[int, ...],
@@ -1136,7 +1197,14 @@ class SessionBankColdTier:
         allow_block_prefix: bool = True,
         resident_duplicates: dict[str, dict[str, Any]] | None = None,
         min_useful_matched_tokens: int = 0,
+        min_restore_point: int = 0,
     ) -> ColdPrefixRestoreRecord | None:
+        # min_restore_point: the lowest point the caller can restore at. A
+        # hybrid row restores at its newest recurrent boundary at or below
+        # the match, which the row's payload.json gives before any tensor is
+        # read; a row whose boundary lies below this point is refused
+        # undecoded and the next one is tried (see _restore_row).
+        #
         # resident_duplicates: token_hash -> {prefix_len, has_mtp_history}
         # for RAM entries the caller has ALREADY proven identity-compatible
         # with this request, snapshot-capable (never live-ref-only), and
@@ -1262,6 +1330,7 @@ class SessionBankColdTier:
                     require_exact_prefix=False,
                     include_gdn_boundaries=True,
                     prefix_restore_tokens=int(candidate_matched),
+                    min_restore_point=int(min_restore_point),
                 )
                 if record is not None:
                     return ColdPrefixRestoreRecord(
@@ -1297,7 +1366,7 @@ class SessionBankColdTier:
         row_has_mtp = "mtp_full" in row_caps or row["mtp_snapshot_epoch"] is not None
         return (not row_has_mtp) or bool(dup.get("has_mtp_history"))
 
-    def _manifest_stats_row(self) -> tuple[int, int, int, int, int]:
+    def _manifest_stats_row(self) -> tuple[Any, ...]:
         """The stats() aggregate, opening the manifest only when it changed.
 
         Before 2.8.2 every stats() call — i.e. every /health and dashboard
@@ -1327,7 +1396,11 @@ class SessionBankColdTier:
                 "COALESCE(SUM(CASE WHEN physical_nbytes > 0 "
                 "THEN physical_nbytes ELSE nbytes END), 0), "
                 "COALESCE(SUM(deduped_nbytes), 0), "
-                "COALESCE(MAX(max(nbytes, logical_nbytes)), 0) FROM entries"
+                "COALESCE(MAX(max(nbytes, logical_nbytes)), 0), "
+                "COUNT(DISTINCT session_id), "
+                "COALESCE(SUM(CASE WHEN session_id IS NULL THEN 1 ELSE 0 END), 0), "
+                "MIN(created_at_s), MAX(created_at_s), "
+                "COALESCE(SUM(CASE WHEN hits = 0 THEN 1 ELSE 0 END), 0) FROM entries"
             ).fetchone()
         row = (
             int(fetched[0]),
@@ -1335,6 +1408,11 @@ class SessionBankColdTier:
             int(fetched[2]),
             int(fetched[3]),
             int(fetched[4]),
+            int(fetched[5]),
+            int(fetched[6]),
+            None if fetched[7] is None else float(fetched[7]),
+            None if fetched[8] is None else float(fetched[8]),
+            int(fetched[9]),
         )
         with self._manifest_stats_lock:
             self._manifest_stats_cache = {
@@ -1373,6 +1451,15 @@ class SessionBankColdTier:
             stats["deduped_bytes"] = int(row[3])
             logical = max(1, int(row[1]))
             stats["dedupe_ratio"] = max(0.0, float(row[3]) / float(logical))
+            # What the store holds, for the dashboard's cache overview: how
+            # many conversations the snapshots belong to (rows written
+            # without a session id are counted apart), how old the oldest
+            # and newest snapshot are, and how many were never restored.
+            stats["sessions"] = int(row[5])
+            stats["entries_without_session"] = int(row[6])
+            stats["oldest_created_at_s"] = row[7]
+            stats["newest_created_at_s"] = row[8]
+            stats["never_restored_entries"] = int(row[9])
             usage = self._managed_disk_usage()
             managed_file_bytes = int(usage.get("managed_file_bytes", 0))
             managed_disk_bytes = int(usage.get("managed_disk_bytes", 0))
@@ -2662,6 +2749,7 @@ class SessionBankColdTier:
         require_exact_prefix: bool = True,
         include_gdn_boundaries: bool = False,
         prefix_restore_tokens: int | None = None,
+        min_restore_point: int = 0,
     ) -> ColdRestoreRecord | None:
         metadata = dict(row)
         token_ids = tuple(int(token) for token in json.loads(str(metadata["token_ids_json"])))
@@ -2723,6 +2811,18 @@ class SessionBankColdTier:
                     self._inc("prefix_restores_without_boundary")
                     self._set_last_miss("ssd_prefix_no_recurrent_boundary")
                     return None
+            if (
+                has_recurrent
+                and boundary_prefix is not None
+                and boundary_prefix < int(min_restore_point)
+            ):
+                # The restore would land below the lowest point the caller
+                # can use (the near lane's floor: its exact prefix in RAM or
+                # on SSD). The lane refused such a candidate only after this
+                # decode, as boundary_not_better.
+                self._inc("prefix_restores_below_caller_floor")
+                self._set_last_miss("ssd_prefix_boundary_below_floor")
+                return None
             # Cache types whose metadata couples rolling state to their
             # tensors must use the exact decoder plus trim; so does a hybrid
             # entry without a boundary when boundary-true restores are off.
@@ -3338,3 +3438,20 @@ def _policy_compatible(entry_policy: str | None, lookup_policy: str | None) -> b
     if entry_policy is None or lookup_policy is None:
         return False
     return entry_policy in _COMMITTED_CACHE_POLICIES and lookup_policy in _COMMITTED_CACHE_POLICIES
+
+
+def _row_carries_generation_state(row: sqlite3.Row) -> bool:
+    """Whether a manifest row holds its entry's final logits and hidden.
+
+    The bank stamps ``mtp_full`` on a row exactly when the entry it writes
+    has both (``SessionBank._cold_enqueue_job``, ``run_live_ref_spill``); a
+    lease returned at a boundary has no logits for its last position and is
+    written without it. Unreadable capabilities count as carrying them, as
+    ``_shadowed_by_resident_duplicate`` assumes a maximal row.
+    """
+
+    try:
+        capabilities = {str(item) for item in json.loads(str(row["capabilities_json"] or "[]"))}
+    except Exception:
+        return True
+    return "mtp_full" in capabilities

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/cli.py

@@ -3660,7 +3660,19 @@ def build_parser() -> argparse.ArgumentParser:
     serve_p.add_argument(
         "--no-auth",
         action="store_true",
-        help="Disable API-key auth for localhost binds (non-localhost still requires a key)",
+        help=(
+            "Disable API-key auth. A non-localhost bind also needs "
+            "--trust-network"
+        ),
+    )
+    serve_p.add_argument(
+        "--trust-network",
+        action="store_true",
+        help=(
+            "With --no-auth, serve without an API key on a non-localhost bind "
+            "(--host 0.0.0.0). Anyone who can reach the port can use the "
+            "model: only on a network you trust"
+        ),
     )
     serve_p.add_argument("--depth", type=int, default=3)
     _add_mtp_toggle_args(serve_p)

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/commands/forge.py

@@ -169,7 +169,10 @@ def _load_json(path: Path) -> dict[str, Any]:
 def _run_dir(out: str | Path, run_id: str) -> Path:
     if not str(run_id).strip():
         raise ForgeError("--run-id is required", code=2)
-    root = Path(out).expanduser()
+    # Absolute, because the steps hand paths inside the run to subprocesses
+    # that run with cwd=run: a relative --out made the contract probe write
+    # its result under run/run/ and calibration report agreement 0.0 (#627).
+    root = Path(out).expanduser().resolve()
     run = root / str(run_id)
     run.mkdir(parents=True, exist_ok=True)
     return run

{mtplx-2.12.2 → mtplx-2.12.3}/mtplx/commands/public.py

@@ -2760,6 +2760,24 @@ def _render_doctor_report(args: Any, report: dict[str, Any]) -> int:
             f"{'available' if thermal.get('available') else 'not configured'}"
             f" ({selected.get('kind') or 'none'})"
         )
+        structured = next(
+            (
+                check
+                for check in (report.get("diagnostics") or {}).get("checks") or ()
+                if check.get("id") == "python.dep.llguidance"
+            ),
+            None,
+        )
+        if structured is not None:
+            if structured.get("status") == "pass":
+                observed = structured.get("observed") or {}
+                print(
+                    "structured output: ready "
+                    f"(llguidance {observed.get('installed_version')})"
+                )
+            else:
+                print(f"structured output: {structured.get('fix')}")
+                print(f"  fix: {structured.get('command')}")
         fence = report.get("compiled_verify") or {}
         if fence:
             print(
@@ -9605,10 +9623,18 @@ def cmd_serve_public(args: Any) -> int:
         _print_serve_start_line(f"error: {exc}")
         return 2
     api_key = getattr(args, "api_key", None)
-    if not _is_localhost_bind(getattr(args, "host", None)) and not api_key:
+    keyless_network = bool(getattr(args, "no_auth", False)) and bool(
+        getattr(args, "trust_network", False)
+    )
+    if (
+        not _is_localhost_bind(getattr(args, "host", None))
+        and not api_key
+        and not keyless_network
+    ):
         payload = {
             "error": "--api-key or --api-key-file is required when --host is not localhost",
             "host": getattr(args, "host", None),
+            "trusted_network_opt_out": "mtplx serve --no-auth --trust-network",
         }
         if getattr(args, "json", False):
             _print(payload)
@@ -9622,6 +9648,10 @@ def cmd_serve_public(args: Any) -> int:
             print(
                 f"try: mtplx {server_command} --host 0.0.0.0 --api-key-file ~/.mtplx/api-key"
             )
+            print(
+                "on a network you trust: mtplx serve --host 0.0.0.0 --no-auth "
+                "--trust-network (anyone who can reach the port can use the model)"
+            )
         return 2
     cli_flags = getattr(args, "_cli_flags", set()) or set()
     _apply_model_id_as_model_default(
@@ -10064,6 +10094,8 @@ def cmd_serve_public(args: Any) -> int:
     # spelling died at this parser with an argparse error.
     if bool(getattr(args, "no_auth", False)):
         cmd.append("--no-auth")
+    if bool(getattr(args, "trust_network", False)):
+        cmd.append("--trust-network")
     # The chat model is already an absolute path by this point, but retrieval
     # references are resolved inside the server, which has no cache directory
     # of its own — so a model pulled into a custom --cache-dir would not be