release: v1.108.169 — the retrieval verdict survives compaction

Two defects in contracts shipped days earlier, both found while checking a
zero-result search I had wrongly treated as proof of absence.

1. Every compact encoder dropped _meta.verdict. schema_driven.encode filters
   _meta through a strict allowlist and "verdict" was in none of the 15 schema
   files, so under MUNCH encoding the whole retrieval-verdict contract was
   invisible: state, channels, coverage, scorer, did_you_mean. Tools without a
   custom encoder kept theirs, so the signal was present where it was least
   needed and absent on search_symbols / search_text / get_ranked_context.

   Worst consequence: server.py mints the citable absent:<sha> ref onto
   _meta.verdict.evidence_ref, and compact callers never received it, along
   with the absence_citable/absence_blocked_by refusal reason. The
   token-saving layer was eating the safety layer.

   meta_keys could not be reused — it flattens to a scalar and would have
   stringified the verdict into a Python repr. New meta_json_blobs parameter
   instead, mirroring the existing json_blobs mechanism; all 15 schemas
   declare _META_JSON = ("verdict",).

2. search_text was never wired for the v1.108.168 rebuilding rule. That
   release wired search_symbols and get_ranked_context only. The absence
   chokepoint is generic — it fires on any _meta.verdict dict — so search_text
   could reach absent and mint a ref while structurally unable to detect a
   rewrite underneath its own scan.

Honest cost: +58 tokens on a 20-result encoded search, +89 on a zero-result
response. Carried at full fidelity; trimming inside the encoder would make
compact and JSON disagree, which is the class of bug being fixed.

No schema/tool-count/INDEX_VERSION change. New tests/test_v1_108_169.py (10),
including a guard that every schema declaring _META also declares verdict in
_META_JSON so a future encoder cannot reintroduce the drop.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: jgravelle

CHANGELOG.md

@@ -2,6 +2,56 @@
 
 All notable changes to jcodemunch-mcp are documented here.
 
+## [1.108.169] - 2026-07-25 - the retrieval verdict survives compaction
+
+### Fixed
+
+- **Every compact encoder silently dropped `_meta.verdict`.** `schema_driven.encode`
+  filters `_meta` through a strict allowlist (`for k in meta_keys: if k in meta`),
+  and `verdict` appeared in **none of the 15** schema files. Under MUNCH encoding
+  the whole retrieval-verdict contract was invisible: `state`, `channels`,
+  `coverage`, `scorer`, and the `did_you_mean` near-misses never reached the
+  caller. Tools *without* a custom encoder (`get_file_content`) kept their
+  verdict, so the signal was present exactly where it was least needed and
+  absent on `search_symbols` / `search_text` / `get_ranked_context` — the three
+  tools the absence contract is built on.
+
+  **The sharpest consequence was on absence evidence.** `server.py`'s chokepoint
+  mints the citable `absent:<sha>` ref onto `_meta.verdict.evidence_ref`, and in
+  compact mode the caller never received it — so a proof the server had already
+  recorded could not be cited, and the in-band `absence_citable:false` /
+  `absence_blocked_by` refusal reason was discarded with it. The token-saving
+  layer was eating the safety layer.
+
+  Fix: new `meta_json_blobs` parameter on `schema_driven.encode`/`decode`,
+  mirroring the existing `json_blobs` mechanism. A structured `_meta` value rides
+  as `__json._meta.<key>` and round-trips as a real dict. **`meta_keys` could not
+  be reused** — that path flattens to a scalar, which would have stringified the
+  verdict into a Python repr. All 15 schemas now declare `_META_JSON = ("verdict",)`.
+
+- **`search_text` was never wired for the v1.108.168 rebuilding rule.** That
+  release added `index_changed=index_changed_since_load(index)` to
+  `search_symbols` and `get_ranked_context` only. The absence chokepoint is
+  **generic** — it fires on any `_meta.verdict` dict — so `search_text` could
+  reach `absent` and mint a citable ref while structurally unable to detect a
+  rewrite underneath its own scan. Same hole as the one .168 closed, left open in
+  the third tool. Now passes `index_changed=`.
+
+### Notes
+
+- **Honest cost:** carrying the verdict adds ~58 tokens to a 20-result encoded
+  search (+18.6%) and ~89 tokens to a zero-result response. The zero-result case
+  is where the value is — that is precisely the response an agent would otherwise
+  read as proven absence. The verdict is carried at **full fidelity**: trimming it
+  inside the encoder would make compact and JSON disagree, which is the exact
+  class of bug being fixed here. If the `ok` verdict is too chatty (`note`
+  duplicates `state` in prose), that is a verdict-construction change for its own
+  release, not something the compaction layer gets to decide.
+- No new tool, no schema/tool-count/INDEX_VERSION change. New
+  `tests/test_v1_108_169.py` (10), including a guard that every schema declaring
+  `_META` also declares `verdict` in `_META_JSON`, so a future encoder cannot
+  reintroduce the drop.
+
 ## [1.108.168] - 2026-07-24 - a rebuild underneath a scan cannot prove absence (5th refusal rule)
 
 ### Fixed

README.md

@@ -129,9 +129,9 @@ is a byte the agent doesn't pay to read.
 <!-- WHATSNEW:START -->
 #### What's new
 
-- **[v1.108.154](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.154)** (2026-07-21) — `surface` CLI subcommand
-- **[v1.108.153](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.153)** (2026-07-21) — tool-surface schema receipt in session stats
-- **[v1.108.152](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.152)** (2026-07-21) — runtime identity resource (#371)
+- **[v1.108.169](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.169)** (2026-07-25) — the retrieval verdict survives compaction
+- **[v1.108.168](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.168)** (2026-07-24) — a rebuild underneath a scan cannot prove absence (5th refusal rule)
+- **[v1.108.167](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.167)** (2026-07-24) — cue-anchored delivery ledger: measure what we hand over twice
 <!-- WHATSNEW:END -->
 
 ![License](https://img.shields.io/badge/license-dual--use-blue)
@@ -346,6 +346,8 @@ Every confidence constant the suite emits traces to a stated basis: **`measured`
 
 An absence claim is also refused when the ground moved under it. A zero-result scan proves nothing if the index was **being rewritten while the scan read it** — the target may sit in rows written after the scan passed them — so that case reports `degraded` and `channels.index: "rebuilding"` instead of `absent`. This is caught by re-checking the index file itself rather than in-process reindex state, because the rebuild is usually driven by a *separate* watcher process that in-process state cannot see. The rebuild is disclosed on every verdict, not only the refused one: a caller reading a successful result still deserves to know the index moved under it, and only the absence *claim* is withheld.
 
+The verdict survives compaction. jCodeMunch's compact wire format encodes `_meta` through a strict allowlist, and the verdict is carried through it deliberately rather than trimmed for bytes — a safety signal the token-saving layer deletes is no safety signal, and a dropped verdict turns "the scan was degraded" into a confident-looking empty result. That applies to the absence `evidence_ref` too: a proof the server has already recorded stays citable in every response format.
+
 Absence claims carry their own receipts: an `absent` or `degraded` verdict discloses a **coverage contract** — what the corpus *excluded* at index time (unsupported extensions, oversize/binary/secret skips, cap-dropped files, zero-symbol files) plus the index generation it was scanned against — so "scanned N symbols, found nothing" can't lie by omission. An index that predates the contract omits the block: coverage unknown is never presented as "nothing was excluded". Every verdict is also pinned to a `scorer` version, and `benchmarks/calibration/planted_queries.json` records planted positive/negative query rates re-measured live in CI — a scorer change without a re-measured artifact fails the build.
 
 The first gold corpus is in: `benchmarks/goldset/` is an authored implementation-pattern corpus (declared subclasses, duck-typed conformers, decorator-registered handlers — plus deliberate false-positive traps: module-homonym base classes, same-name-different-domain methods, substring decorator matches), fully labeled with per-pair rationale. `benchmarks/goldset/measure.py` re-runs `find_implementations` against it and CI asserts the committed results (`benchmarks/provenance/channel_accuracy.json`) match the live measurement — the numbers literally cannot drift from the reproducible run. Each resolution channel's registry entry now carries its `measured_ref` (precision/recall on the corpus) beside the declared ranking prior, and `_meta.confidence_provenance` surfaces both. Scope is stated in the artifact: authored-pattern discrimination, not in-the-wild base rates.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jcodemunch-mcp"
-version = "1.108.168"
+version = "1.108.169"
 description = "Token-efficient MCP server for source code exploration via tree-sitter AST parsing"
 readme = "README.md"
 requires-python = ">=3.10"

src/jcodemunch_mcp/encoding/schema_driven.py

@@ -78,6 +78,7 @@ def encode(
     nested_dicts: dict[str, list[str]] | None = None,
     meta_keys: Iterable[str] = (),
     json_blobs: Iterable[str] = (),
+    meta_json_blobs: Iterable[str] = (),
 ) -> tuple[str, str]:
     tables = list(tables)
     nested_dicts = nested_dicts or {}
@@ -110,6 +111,16 @@ def encode(
     for k in meta_keys:
         if k in meta:
             scalar_payload[f"_meta.{k}"] = meta[k]
+    # Structured _meta values (dicts/lists) that must survive compaction intact.
+    # meta_keys flattens to a scalar, which would stringify a dict — the retrieval
+    # verdict is the reason this exists: dropping it hands the agent a confident
+    # zero-result answer with no way to know the scan was degraded (and silently
+    # discards the absence evidence_ref minted in call_tool).
+    for k in meta_json_blobs:
+        if k in meta:
+            scalar_payload[f"__json._meta.{k}"] = json.dumps(
+                meta[k], separators=(",", ":")
+            )
     for k in json_blobs:
         if k in response:
             scalar_payload[f"__json.{k}"] = json.dumps(response[k], separators=(",", ":"))
@@ -173,6 +184,7 @@ def decode(
     nested_dicts: dict[str, list[str]] | None = None,
     meta_keys: Iterable[str] = (),
     json_blobs: Iterable[str] = (),
+    meta_json_blobs: Iterable[str] = (),
     scalar_types: Mapping[str, str] | None = None,
 ) -> dict:
     tables = list(tables)
@@ -224,6 +236,13 @@ def decode(
         prefixed = f"_meta.{k}"
         if prefixed in raw_scalars:
             meta_out[k] = _coerce(raw_scalars[prefixed], stypes.get(prefixed, "str"))
+    for k in meta_json_blobs:
+        prefixed = f"__json._meta.{k}"
+        if prefixed in raw_scalars:
+            try:
+                meta_out[k] = json.loads(raw_scalars[prefixed])
+            except Exception:
+                meta_out[k] = raw_scalars[prefixed]
     if meta_out:
         result["_meta"] = meta_out
     # JSON blobs

src/jcodemunch_mcp/encoding/schemas/find_importers.py

@@ -16,12 +16,13 @@
 ]
 _SCALARS = ("repo", "file_path", "importer_count", "note")
 _META = ("timing_ms", "truncated", "tokens_saved", "total_tokens_saved")
+_META_JSON = ("verdict",)  # structured _meta that must survive compaction
 _JSON = ("results",)
 
 
 def encode(tool: str, response: dict) -> tuple[str, str]:
-    return sd.encode(tool, response, ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, json_blobs=_JSON)
+    return sd.encode(tool, response, ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON)
 
 
 def decode(payload: str) -> dict:
-    return sd.decode(payload, _TABLES, _SCALARS, meta_keys=_META, json_blobs=_JSON)
+    return sd.decode(payload, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON)

src/jcodemunch_mcp/encoding/schemas/find_references.py

@@ -18,6 +18,7 @@
 ]
 _SCALARS = ("repo", "identifier", "reference_count", "note")
 _META = ("timing_ms", "truncated", "tokens_saved", "total_tokens_saved")
+_META_JSON = ("verdict",)  # structured _meta that must survive compaction
 _JSON = ("results", _EMPTY_GROUPS_KEY)
 
 
@@ -78,12 +79,12 @@ def _regroup(decoded: dict) -> dict:
 
 def encode(tool: str, response: dict) -> tuple[str, str]:
     if "references" not in response:
-        return sd.encode(tool, response, ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, json_blobs=_JSON)
-    return sd.encode(tool, _flatten(response), ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, json_blobs=_JSON)
+        return sd.encode(tool, response, ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON)
+    return sd.encode(tool, _flatten(response), ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON)
 
 
 def decode(payload: str) -> dict:
-    decoded = sd.decode(payload, _TABLES, _SCALARS, meta_keys=_META, json_blobs=_JSON)
+    decoded = sd.decode(payload, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON)
     if _ROWS_KEY in decoded:
         return _regroup(decoded)
     return decoded

src/jcodemunch_mcp/encoding/schemas/get_blast_radius.py

@@ -26,18 +26,19 @@
 )
 _NESTED = {"symbol": ["id", "name", "kind", "file", "line"]}
 _META = ("timing_ms",)
+_META_JSON = ("verdict",)  # structured _meta that must survive compaction
 _JSON = ("impact_by_depth", "callers", "cross_repo_confirmed")
 
 
 def encode(tool: str, response: dict) -> tuple[str, str]:
     return sd.encode(
         tool, response, ENCODING_ID, _TABLES, _SCALARS,
-        nested_dicts=_NESTED, meta_keys=_META, json_blobs=_JSON,
+        nested_dicts=_NESTED, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON,
     )
 
 
 def decode(payload: str) -> dict:
     return sd.decode(
         payload, _TABLES, _SCALARS,
-        nested_dicts=_NESTED, meta_keys=_META, json_blobs=_JSON,
+        nested_dicts=_NESTED, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON,
     )

src/jcodemunch_mcp/encoding/schemas/get_call_hierarchy.py

@@ -31,18 +31,19 @@
 _SCALARS = ("repo", "direction", "depth", "depth_reached", "caller_count", "callee_count")
 _NESTED = {"symbol": ["id", "name", "kind", "file", "line"]}
 _META = ("timing_ms", "methodology", "confidence_level", "source", "tip")
+_META_JSON = ("verdict",)  # structured _meta that must survive compaction
 _JSON = ("resolution_tiers",)
 
 
 def encode(tool: str, response: dict) -> tuple[str, str]:
     return sd.encode(
         tool, response, ENCODING_ID, _TABLES, _SCALARS,
-        nested_dicts=_NESTED, meta_keys=_META, json_blobs=_JSON,
+        nested_dicts=_NESTED, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON,
     )
 
 
 def decode(payload: str) -> dict:
     return sd.decode(
         payload, _TABLES, _SCALARS,
-        nested_dicts=_NESTED, meta_keys=_META, json_blobs=_JSON,
+        nested_dicts=_NESTED, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON,
     )

src/jcodemunch_mcp/encoding/schemas/get_dependency_cycles.py

@@ -17,6 +17,7 @@
 ]
 _SCALARS = ("repo", "cycle_count")
 _META = ("timing_ms",)
+_META_JSON = ("verdict",)  # structured _meta that must survive compaction
 
 
 def encode(tool: str, response: dict) -> tuple[str, str]:
@@ -26,11 +27,11 @@ def encode(tool: str, response: dict) -> tuple[str, str]:
             {"length": len(c), "files": _CYCLE_SEP.join(c)}
             for c in r["cycles"] if isinstance(c, list)
         ]
-    return sd.encode(tool, r, ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META)
+    return sd.encode(tool, r, ENCODING_ID, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON)
 
 
 def decode(payload: str) -> dict:
-    result = sd.decode(payload, _TABLES, _SCALARS, meta_keys=_META)
+    result = sd.decode(payload, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON)
     if "cycles" in result:
         result["cycles"] = [
             c["files"].split(_CYCLE_SEP) for c in result["cycles"]

src/jcodemunch_mcp/encoding/schemas/get_dependency_graph.py

@@ -26,17 +26,18 @@
     "node_count", "edge_count",
 )
 _META = ("timing_ms", "truncated", "cross_repo", "tokens_saved", "total_tokens_saved")
+_META_JSON = ("verdict",)  # structured _meta that must survive compaction
 _JSON = ("nodes", "neighbors")
 
 
 def encode(tool: str, response: dict) -> tuple[str, str]:
     return sd.encode(
         tool, response, ENCODING_ID, _TABLES, _SCALARS,
-        meta_keys=_META, json_blobs=_JSON,
+        meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON,
     )
 
 
 def decode(payload: str) -> dict:
     return sd.decode(
-        payload, _TABLES, _SCALARS, meta_keys=_META, json_blobs=_JSON,
+        payload, _TABLES, _SCALARS, meta_keys=_META, meta_json_blobs=_META_JSON, json_blobs=_JSON,
     )