chore(sync): mirror backend .py + Dockerfile to Space (hf-sync-backend)

Automated backend sync from szl-holdings/a11oy main via hf-sync-backend.
Updated (differed from the Space): Dockerfile, a11oy_frontier_page.py, serve.py, szl_agentic_loop.py, szl_frontier_manifest.py, szl_gpu_quant.py, szl_involution_probe.py, szl_runtime_contracts.py
Deleted (gone from the repo + Dockerfile COPY set): (none)

Keeps the Space-built backend (serve.py + the Dockerfile-COPY'd .py
modules) identical to GitHub main so the Space never rebuilds from a
stale backend, new endpoints don't 404 there, and orphaned modules
removed from the repo don't linger in the Space tree.

Dockerfile

@@ -145,6 +145,11 @@ COPY szl_waqay_security_loop.py ./
 # reviewed source contracts.
 COPY szl_claim_rupture_gate.py ./
 COPY schemas/evidenceos/ ./schemas/evidenceos/
+# Wave 38 evidence surfaces: involution probe + runtime contracts + committed quant
+# benchmark receipt (read-only, validated+signature-checked at serve time).
+COPY szl_involution_probe.py ./
+COPY szl_runtime_contracts.py ./
+COPY benchmarks/quant_live/receipts/latest.json ./benchmarks/quant_live/receipts/latest.json
 # Quantum Utility Gate wave 16: pure-stdlib proposal analysis only.  No provider
 # SDK, QPU call, credential path, external effector, or finance-engine coupling.
 COPY szl_quantum_utility.py ./

a11oy_frontier_page.py

@@ -20,7 +20,8 @@ The whole stack on one surface:
   - the multi-node sovereign GPU fabric (REAL reachability probe),
   - the MODELED orbital tier (links out to the /orbital page),
   - governance / restraint (codified doctrine + signed DSSE receipts),
-  - the ROADMAP composite inference-provenance-receipt play (clearly labeled).
+  - the composite inference-provenance capability (UNAVAILABLE until a real write
+    has minted an independently visible artifact).
 
 HONESTY (doctrine v11, non-negotiable):
   * A persistent honest banner is pinned to the top of every viewport and a
@@ -687,7 +688,7 @@ function tileCard(t) {{
   else if (label === 'SAMPLE')
     banner = `<div class="tile-banner sample">SAMPLE — illustrative value, never billable or live.</div>`;
   else if (label === 'UNAVAILABLE')
-    banner = `<div class="tile-banner unavailable">UNAVAILABLE — sub-source down right now; reported honestly, not faked.</div>`;
+    banner = `<div class="tile-banner unavailable">UNAVAILABLE — source, dependency, or required artifact is not operationally evidenced.</div>`;
   return `<div class="card" style="--edge:${{edge}}">
     <div class="cat">${{esc(t.category || '')}}</div>
     <h3><span>${{esc(t.name || '')}}</span><span class="badge ${{c}}">${{esc(label)}}</span></h3>
@@ -792,6 +793,11 @@ document.getElementById('brain-query-form').addEventListener('submit', async eve
     const tiles = m.capabilities || [];
     const s = m.summary || {{}};
     const lc = s.label_counts || {{}};
+    const source = s.source_reachability || {{state:'UNKNOWN'}};
+    const readiness = s.operational_readiness || {{state:'UNKNOWN', ready:false, blocked_tiles:[]}};
+    const blockedNames = Array.isArray(readiness.blocked_tiles)
+      ? readiness.blocked_tiles.map(row => row && row.name ? row.name : row).filter(Boolean)
+      : [];
 
     // roll-up chips (honest counts straight from the manifest)
     document.getElementById('rollup').innerHTML = [
@@ -799,18 +805,22 @@ document.getElementById('brain-query-form').addEventListener('submit', async eve
       `<span class="chip">MEASURED <b>${{esc(lc.MEASURED || 0)}}</b></span>`,
       `<span class="chip">MODELED <b>${{esc(lc.MODELED || 0)}}</b></span>`,
       `<span class="chip">ROADMAP <b>${{esc(lc.ROADMAP || 0)}}</b></span>`,
-      `<span class="chip">all sources live: <b>${{esc(String(s.all_sources_live))}}</b></span>`,
+      `<span class="chip">source reachability <b>${{esc(source.state || 'UNKNOWN')}}</b></span>`,
+      `<span class="chip">operational readiness <b>${{esc(readiness.state || 'UNKNOWN')}}</b></span>`,
       (s.degraded_tiles && s.degraded_tiles.length)
         ? `<span class="chip">degraded: <b>${{esc(s.degraded_tiles.join(', '))}}</b></span>` : '',
+      blockedNames.length
+        ? `<span class="chip">not ready: <b>${{esc(blockedNames.join(', '))}}</b></span>` : '',
     ].join('');
 
     document.getElementById('grid').innerHTML = tiles.map(tileCard).join('');
     drawConstellation(tiles);
 
     const el = document.getElementById('status');
-    el.textContent = 'live · composed from ' + esc(MANIFEST_EP) +
-      ' · ' + esc(s.tiles ?? tiles.length) + ' tiles · all_sources_live=' +
-      esc(String(s.all_sources_live));
+    el.textContent = 'manifest reachable · composed from ' + esc(MANIFEST_EP) +
+      ' · ' + esc(s.tiles ?? tiles.length) + ' tiles · source=' +
+      esc(source.state || 'UNKNOWN') + ' · operational=' +
+      esc(readiness.state || 'UNKNOWN');
     document.getElementById('subline').innerHTML =
       'Every capability we run, on one screen — composed live by <code>/frontier/manifest</code>. ' +
       'Each tile shows its <b>honest label</b> and a <b>link to the proof</b>. No label is upgraded.';

serve.py

@@ -77,8 +77,13 @@ def gov_envelope(payload=None, status="REAL", citations=None, reason=None, **ext
     return out
 # === END GOVERNED ENVELOPE ===
 
-# RESET: SPA is served from /app/static (repo root mirrors dist/public). No /console subdir.
-STATIC_DIR = Path("/app/static")
+# RESET: the image serves the SPA from /app/static after Docker copies
+# console/ there.  Local verification must resolve the same source tree rather
+# than trying to return a container-only path (which turns an otherwise honest
+# 404 or history fallback into a 500).
+_IMAGE_STATIC_DIR = Path("/app/static")
+_LOCAL_STATIC_DIR = Path(__file__).resolve().parent / "console"
+STATIC_DIR = _IMAGE_STATIC_DIR if (_IMAGE_STATIC_DIR / "index.html").is_file() else _LOCAL_STATIC_DIR
 ASSETS_DIR = STATIC_DIR / "assets"
 INDEX_HTML = STATIC_DIR / "index.html"
 A11OY_BACKEND_PORT = 8081
@@ -2012,6 +2017,18 @@ try:
 except Exception as _szl_gq_e:  # pragma: no cover
     print(f"[a11oy] GPU-Quant engine NOT registered: {_szl_gq_e!r}", file=__import__("sys").stderr)
 
+# -- EvidenceOS involution probe: bounded clean-room boundary/bulk decomposition.
+# The endpoint requires a caller-declared finite involution, performs no writes or
+# effectors, and returns a content digest plus explicit PROVEN/MODELED/REPORTED scope.
+try:
+    import szl_involution_probe as _szl_involution_probe
+    _szl_involution_probe.register(app, ns="a11oy")
+    print("[a11oy] EvidenceOS involution probe registered: /api/a11oy/v1/evidenceos/involution/*",
+          file=__import__("sys").stderr)
+except Exception as _szl_involution_e:  # pragma: no cover
+    print(f"[a11oy] EvidenceOS involution probe NOT registered: {_szl_involution_e!r}",
+          file=__import__("sys").stderr)
+
 # ── Agentic PINN + Physical-Bounds Certifier MESH (pinn-bounds) — closes the audited
 # gap where the PINN / FE-NO Physics-ML verticals lived ONLY in `platform` and were
 # NOT in a11oy's governed /api/a11oy/v1/<name> route table. Adds /api/a11oy/v1/pinn/*:
@@ -3447,6 +3464,18 @@ except Exception as _vsp_e:
     print(f"[a11oy] vsp-otel VSP skipped: {_vsp_e!r}", file=_vsp_sys.stderr)
 # --- end vsp-otel VSP ---
 
+# -- Runtime contracts: process liveness, fail-closed readiness, build identity,
+# explicit OTEL exporter/collector evidence, and soft-404 protection for unknown
+# file-like discovery paths. Read-only GETs; no receipt minting or external calls.
+try:
+    import szl_runtime_contracts as _szl_runtime_contracts
+    _runtime_contracts_status = _szl_runtime_contracts.register(app, ns="a11oy")
+    print(f"[a11oy] Runtime contracts registered: {_runtime_contracts_status}",
+          file=__import__("sys").stderr)
+except Exception as _runtime_contracts_e:  # pragma: no cover
+    print(f"[a11oy] Runtime contracts NOT registered: {_runtime_contracts_e!r}",
+          file=__import__("sys").stderr)
+
 
 # ── Live 3D Wires (PURIQ / Doctrine v12) — ADDITIVE, re-pinned FIRST ─────────
 # Registered immediately after the app is constructed so FastAPI's ordered route
@@ -3654,7 +3683,9 @@ except Exception as _sec_hdr_e:  # pragma: no cover
 # ===========================================================================
 from fastapi.responses import RedirectResponse as _PTG_Redirect
 
-_PTG_WEB = Path("/app/web")
+_PTG_IMAGE_WEB = Path("/app/web")
+_PTG_LOCAL_WEB = Path(__file__).resolve().parent / "web"
+_PTG_WEB = _PTG_IMAGE_WEB if _PTG_IMAGE_WEB.is_dir() else _PTG_LOCAL_WEB
 
 def _ptg_serve(filename: str):
     async def _h() -> Response:

szl_agentic_loop.py

@@ -10,9 +10,11 @@
 # chained, signed receipt.
 #
 # WHAT IT EXPOSES (all registered BEFORE the SPA catch-all via routes.insert(0)):
-#   GET  /mcp/                          — MCP discovery card (canonical live MCP)
+#   GET  /mcp/                          — MCP runtime discovery (declaration only)
 #   POST /mcp/                          — MCP JSON-RPC (initialize, tools/list, tools/call)
 #   GET  /api/<ns>/v1/agent/tools       — plain tool catalog (mirror of MCP tools/list)
+#   GET  /api/<ns>/v1/agent/evidence    — observed, read-only receipt evidence
+#   GET  /api/<ns>/v1/agent/invocations — bounded, ephemeral receipt summaries
 #   POST /api/<ns>/v1/agent/run         — the GOVERNED AGENT RUN (the whole loop)
 #   POST /api/<ns>/v1/agent/verify-chain— re-verify a run's chained receipt
 #   GET  /ask-and-act                   — the consumer/investor UI (one button)
@@ -36,10 +38,17 @@ from __future__ import annotations
 import hashlib
 import json
 import math
+import threading
 import time
 import uuid
 from datetime import datetime, timezone
 
+
+# The Hatun read surface exposes only a bounded, in-process summary of receipts
+# that this module actually observed creating. It is deliberately ephemeral: a
+# restart clears the feed, and no GET handler signs or appends anything.
+_HATUN_FEED_LIMIT = 32
+
 # ----------------------------------------------------------------------------
 # FORMULA WIRING (ADDITIVE 2026-06-06): the ~80 kernel-verified theorems wired
 # to REAL work. szl_formula_wiring exposes deterministic mechanisms that COMPUTE
@@ -747,9 +756,14 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
     from starlette.responses import JSONResponse, HTMLResponse
     from starlette.requests import Request
 
-    # in-memory chain of FULL runs (each run is itself a chained sub-ledger).
+    # In-memory chain of full runs (each run is itself a chained sub-ledger).
     _RUN_CHAIN = []  # list of {run_id, final_hash, prev_run_hash}
 
+    # Bounded read model derived only from receipts created by _do_run. This is
+    # not a durable ledger and it is never populated by a GET request.
+    _HATUN_EVIDENCE = []
+    _HATUN_EVIDENCE_LOCK = threading.Lock()
+
     def _do_run(query: str, action: str, severity: str, confidence: float,
                 reversible: bool, untrusted_input: str = "", approval_grant=None,
                 precondition_hash=None):
@@ -823,7 +837,7 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
                         "quarantined": True,
                         "feeds_decision": False})
 
-        # ---- HOP 3: MCP tool-call (policy_check tool, via the canonical MCP) ----
+        # ---- HOP 3: MCP tool-call (policy_check tool, via the registered MCP) ----
         with tr.span("tool_call", "mcp") as sp:
             tool_name = "policy_check"
             tool_input = {"action": action, "severity": severity,
@@ -1023,6 +1037,7 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
         sealed = _chain_receipt("emit", {"decision": decision,
                                          "emitted": effect["emitted"],
                                          "signed": bool(envelope.get("signed"))})
+        receipt_has_signature = bool(envelope.get("signed") and envelope.get("signatures"))
 
         # ---- OPERATOR + GRAPH + UNIFYING FORMULA WIRING (real, executed on the
         # ---- SEALED chain) — these mechanisms run on the actual receipts below.
@@ -1088,11 +1103,12 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
                       "decision": decision}
         _RUN_CHAIN.append(run_record)
 
-        return {
+        result = {
             "run_id": tr.trace_id,
             "decision": decision,
             "emitted": effect["emitted"],
-            "summary": _plain_summary(decision, action, effect, reasons, trust, trust_pass),
+            "summary": _plain_summary(decision, action, effect, reasons, trust, trust_pass,
+                                      receipt_has_signature),
             "retrieved": chunks,
             "untrusted": {"present": bool(untrusted_input),
                           "excerpt": (untrusted_input or "")[:240],
@@ -1118,25 +1134,34 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
             "signed_receipt": envelope,
             "chain_final_hash": prev_hash,
             "chain_depth": len(chain),
-            "signer": signer_label,
+            "signer": signer_label if receipt_has_signature else None,
+            "signer_claim_status": ("SIGNATURE_PRESENT_UNVERIFIED"
+                                    if receipt_has_signature else "UNAVAILABLE"),
             "verify_hint": ("Re-verify with POST /api/%s/v1/agent/verify-chain "
-                            "(send the whole run object back). The final receipt is "
-                            "signed; fetch /cosign.pub to verify offline." % ns),
+                            "(send the whole run object back). A signature is not called "
+                            "valid until that verifier succeeds." % ns),
             "doctrine": "v11",
             "honesty": ("Trust score is advisory (Conjecture 1). RAG retrieves over the "
-                        "in-image governance corpus. The receipt is %s." % signer_label),
+                        "in-image governance corpus. Receipt signature state is %s."
+                        % ("PRESENT_UNVERIFIED" if receipt_has_signature else "UNAVAILABLE")),
         }
-
-    def _plain_summary(decision, action, effect, reasons, trust, trust_pass):
+        _remember_hatun_receipt(result, decision_payload, tool_name)
+        return result
+
+    def _plain_summary(decision, action, effect, reasons, trust, trust_pass,
+                       receipt_has_signature):
+        receipt_note = ("A receipt envelope with signature bytes was produced; verification "
+                        "is a separate check." if receipt_has_signature else
+                        "The receipt is UNSIGNED because no signature evidence was available.")
         if decision == "ALLOW":
             return ("Allowed. After retrieving the relevant guidance, calling the policy "
                     "tool, passing the safety gate and the advisory trust check (score "
-                    "%.2f), the action \"%s\" was %s. A signed receipt was produced."
-                    % (trust, action, effect["effect"]))
+                    "%.2f), the action \"%s\" was %s. %s"
+                    % (trust, action, effect["effect"], receipt_note))
         why = "; ".join(reasons) if reasons else ("advisory trust score %.2f below the floor" % trust)
         return ("Blocked. The safety/trust gate denied \"%s\" because: %s. No action was "
-                "taken — only a signed deny receipt was produced. This is the gate working."
-                % (action, why))
+                "taken. %s This is the gate working."
+                % (action, why, receipt_note))
 
     def _verify_chain(run: dict):
         """Re-verify a run object: (1) chain integrity (each prev_hash links and each
@@ -1188,6 +1213,122 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
                      "Flip any byte in any receipt body and chain_intact becomes false."),
         }
 
+    def _signature_evidence_status(run: dict, verification: dict) -> str:
+        """Classify only evidence present on an observed receipt.
+
+        A self-reported ``signed`` flag is not enough to call a signature
+        verified. Verification requires the host-provided verifier to have run
+        and returned a positive result.
+        """
+        envelope = run.get("signed_receipt") or {}
+        has_signature = bool(envelope.get("signed") and envelope.get("signatures"))
+        if (verify_fn is not None and has_signature
+                and verification.get("signature_valid") is True):
+            return "VERIFIED"
+        if verify_fn is not None and has_signature:
+            return "INVALID"
+        if has_signature:
+            return "PRESENT_UNVERIFIED"
+        return "UNAVAILABLE"
+
+    def _remember_hatun_receipt(run: dict, decision_payload: dict, tool_name: str) -> None:
+        """Append a bounded, redacted summary of an actual governed-run receipt."""
+        verification = _verify_chain(run)
+        signature_status = _signature_evidence_status(run, verification)
+        if run.get("decision") == "DENY":
+            outcome = "DENY"
+        elif run.get("emitted"):
+            outcome = "ALLOW_EMITTED"
+        else:
+            outcome = "ALLOW_HELD"
+        entry = {
+            "namespace": ns,
+            "ts": decision_payload.get("issued_at"),
+            "run_id": run.get("run_id"),
+            "source": "governed_agent_run_receipt",
+            "tool": tool_name,
+            "outcome": outcome,
+            "receipt_hash": run.get("chain_final_hash"),
+            "chain_depth": run.get("chain_depth"),
+            "chain_status": ("OBSERVED_INTACT"
+                             if verification.get("chain_intact") is True
+                             else "OBSERVED_BROKEN"),
+            "signature_status": signature_status,
+            "signer": signer_label if signature_status == "VERIFIED" else None,
+            "maturity": "OBSERVED",
+        }
+        with _HATUN_EVIDENCE_LOCK:
+            _HATUN_EVIDENCE.append(entry)
+            overflow = len(_HATUN_EVIDENCE) - _HATUN_FEED_LIMIT
+            if overflow > 0:
+                del _HATUN_EVIDENCE[:overflow]
+
+    def _hatun_invocation_contract() -> dict:
+        with _HATUN_EVIDENCE_LOCK:
+            items = [dict(item) for item in reversed(_HATUN_EVIDENCE)]
+        return {
+            "schema": "szl.hatun.invocation-feed.v1",
+            "namespace": ns,
+            "status": "OBSERVED" if items else "UNKNOWN",
+            "read_only": True,
+            "get_mints_receipt": False,
+            "ephemeral": True,
+            "limit": _HATUN_FEED_LIMIT,
+            "count": len(items),
+            "source": "bounded in-process summaries of actual governed agent-run receipts",
+            "items": items,
+        }
+
+    def _hatun_evidence_contract() -> dict:
+        feed = _hatun_invocation_contract()
+        items = feed["items"]
+        latest = items[0] if items else None
+        verified = next((item for item in items
+                         if item.get("signature_status") == "VERIFIED"), None)
+        if verified:
+            signer = {"status": "OBSERVED_VERIFIED", "label": verified.get("signer")}
+        elif any(item.get("signature_status") in ("PRESENT_UNVERIFIED", "INVALID")
+                 for item in items):
+            signer = {"status": "UNVERIFIED", "label": None}
+        elif items:
+            signer = {"status": "UNAVAILABLE", "label": None}
+        else:
+            signer = {"status": "UNKNOWN", "label": None}
+
+        return {
+            "schema": "szl.hatun.evidence.v1",
+            "namespace": ns,
+            "read_only": True,
+            "get_mints_receipt": False,
+            "runtime": {
+                "status": "AVAILABLE",
+                "mcp_endpoint": "/mcp/",
+                "protocol_version": "2024-11-05",
+            },
+            "tool_catalog": {
+                "status": "RUNTIME_DECLARED",
+                "count": len(_tool_catalog(ns)),
+                "evidence_boundary": "declaration and route presence; not execution proof",
+            },
+            "signer": signer,
+            "receipt_chain": {
+                "status": latest.get("chain_status") if latest else "UNKNOWN",
+                "observed_receipts": len(items),
+                "latest_receipt_hash": latest.get("receipt_hash") if latest else None,
+                "latest_chain_depth": latest.get("chain_depth") if latest else None,
+            },
+            "invocations": {
+                "status": feed["status"],
+                "count": feed["count"],
+                "ephemeral": True,
+                "endpoint": "/api/hatun/invocations" if ns == "a11oy"
+                            else "/api/%s/v1/agent/invocations" % ns,
+            },
+            "honesty": ("No receipt or signer claim is promoted by this GET. UNKNOWN and "
+                        "UNAVAILABLE remain visible until an observed governed run supplies "
+                        "the corresponding evidence."),
+        }
+
     # ------------------------------------------------------------------ #
     # OUROBOROS CLOSED LOOP (ADDITIVE 2026-07-03, default-OFF, honest).
     # Wraps the single governed pass `_do_run` into a BOUNDED, WITNESSED,
@@ -1398,7 +1539,7 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
         except Exception:  # pragma: no cover - SGH must never take the cycle down
             return core
 
-    # ---- MCP JSON-RPC handler (canonical live MCP) ----
+    # ---- MCP JSON-RPC handler (runtime-declared MCP surface) ----
     async def _mcp_post(request: Request):
         try:
             body = await request.json()
@@ -1496,18 +1637,21 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
         return {"_error": True, "detail": "unknown tool: %s" % name}
 
     async def _mcp_get(request: Request):
-        # MCP discovery card — proves a real, live, canonical MCP surface.
+        # The response proves this route was reachable for this request. Its tool
+        # list remains a runtime declaration, not proof of tool execution.
         return JSONResponse({
             "name": "szl-%s-mcp" % ns,
-            "title": "SZL %s — canonical governed MCP" % ns,
+            "title": "SZL %s — governed MCP runtime" % ns,
             "protocol": "Model Context Protocol (JSON-RPC over Streamable HTTP)",
             "protocolVersion": "2024-11-05",
             "transport": {"post": "/mcp/  (JSON-RPC: initialize, tools/list, tools/call)"},
             "tools": _tool_catalog(ns),
             "tool_count": len(_tool_catalog(ns)),
-            "canonical": True,
-            "note": ("This is the single canonical live MCP for %s. The previously "
-                     "advertised standalone MCP Spaces are retired; this surface replaces them." % ns),
+            "runtime_status": "AVAILABLE",
+            "catalog_evidence": "RUNTIME_DECLARED",
+            "execution_evidence": "/api/%s/v1/agent/evidence" % ns,
+            "note": ("This GET confirms route reachability and returns the catalog declared "
+                     "by this runtime. It does not prove a tool ran or a receipt was signed."),
             "doctrine": "v11",
         })
 
@@ -1529,7 +1673,17 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
 
     async def _agent_tools(request: Request):
         return JSONResponse({"tools": _tool_catalog(ns), "count": len(_tool_catalog(ns)),
-                             "canonical_mcp": "/mcp/", "doctrine": "v11"})
+                             "mcp_endpoint": "/mcp/",
+                             "catalog_evidence": "RUNTIME_DECLARED",
+                             "doctrine": "v11"})
+
+    async def _agent_evidence(request: Request):
+        return JSONResponse(_hatun_evidence_contract(),
+                            headers={"Cache-Control": "no-store"})
+
+    async def _agent_invocations(request: Request):
+        return JSONResponse(_hatun_invocation_contract(),
+                            headers={"Cache-Control": "no-store"})
 
     async def _agent_governance_standards(request: Request):
         return JSONResponse(governance_standards_note())
@@ -1595,6 +1749,10 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
         Route("/mcp", _mcp_any, methods=["GET", "POST"], name="%s_mcp_noslash" % ns),
         Route("/api/%s/v1/agent/run" % ns, _agent_run, methods=["POST"], name="%s_agent_run" % ns),
         Route("/api/%s/v1/agent/tools" % ns, _agent_tools, methods=["GET"], name="%s_agent_tools" % ns),
+        Route("/api/%s/v1/agent/evidence" % ns, _agent_evidence,
+              methods=["GET"], name="%s_agent_evidence" % ns),
+        Route("/api/%s/v1/agent/invocations" % ns, _agent_invocations,
+              methods=["GET"], name="%s_agent_invocations" % ns),
         Route("/api/%s/v1/agent/governance-standards" % ns, _agent_governance_standards,
               methods=["GET"], name="%s_agent_gov_standards" % ns),
         Route("/api/%s/v1/agent/verify-chain" % ns, _agent_verify, methods=["POST"], name="%s_agent_verify" % ns),
@@ -1602,6 +1760,13 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
         Route("/ask-and-act", _ask_and_act_ui, methods=["GET"], name="%s_ask_and_act" % ns),
         Route("/governed-run", _ask_and_act_ui, methods=["GET"], name="%s_governed_run" % ns),
     ]
+    if ns == "a11oy":
+        routes.extend([
+            Route("/api/hatun/evidence", _agent_evidence, methods=["GET"],
+                  name="hatun_evidence"),
+            Route("/api/hatun/invocations", _agent_invocations, methods=["GET"],
+                  name="hatun_invocations"),
+        ])
     # insert at position 0 so they win over the SPA catch-all (the known gotcha).
     for r in reversed(routes):
         app.router.routes.insert(0, r)

szl_frontier_manifest.py

@@ -10,7 +10,7 @@ capability as a labeled tile. The manifest is REAL data pulled IN-PROCESS from t
 already-wired surfaces — it never fabricates a status, joule, receipt, or label:
 
   * energy operator  — szl_energy_operator.handle_status()      (MEASURED joules/jobs)
-  * energy ledger    — szl_energy_ledger.handle_ledger()         (signed receipt chain)
+  * energy ledger    — szl_energy_ledger.handle_ledger()         (tamper-evident chain)
   * energy provenance— szl_energy_provenance summary             (tamper-evident chain)
   * UDS bundle sig   — szl_uds_fleet narrative (cosign+Rekor pattern)  (label honest)
   * orbital tier     — szl_orbital_topology / _projection         (MODELED roadmap)
@@ -34,12 +34,12 @@ DOCTRINE v11 (this surface is a roll-up — be ruthless about honesty):
   - If a sub-source raises or is down, its tile says so honestly
     (label "UNAVAILABLE", ok:false, the error) — we degrade the tile, never the truth,
     and the manifest as a whole still returns 200 with the surviving tiles.
-  - The #1 frontier play (composite inference-provenance receipt) is surfaced ONLY as
-    a clearly-labeled ROADMAP concept tile that NAMES its existing parts (the MEASURED
-    joule receipt + the MODELED model-hash) — no fabricated composite artifact is minted.
+  - The composite inference-provenance capability is UNAVAILABLE until a real governed
+    action has minted an artifact. A read never creates one and an unminted capability is
+    never presented as operational merely because its source module is reachable.
 
-The composition is the whole point: SZL already holds the parts (signed energy
-receipts MEASURED, signed UDS bundle MEASURED, governance doctrine MEASURED, MODELED
+The composition is the whole point: SZL already holds the parts (tamper-evident
+energy receipts MEASURED, signed UDS bundle MEASURED, governance doctrine MEASURED, MODELED
 orbital roadmap). This manifest shows them as one frontier surface, honestly labeled.
 """
 from __future__ import annotations
@@ -57,7 +57,7 @@ UNAVAILABLE = "UNAVAILABLE"
 _API = "/api/a11oy/v1"
 
 # UNIVERSAL Khipu verifier (judge-facing audit layer, szl_khipu_verify). A reader
-# pastes ANY receipt digest from ANY organ and gets an INDEPENDENT, COMPUTED
+# pastes ANY receipt digest from ANY organ and gets a COMPUTED integrity
 # PASS|FAIL|NOT_FOUND (SHA3-256 seal recompute + prev-link re-walk to genesis).
 # This is the REAL endpoint each verifiable tile's `verify` field points to. Only
 # tiles whose receipts genuinely live in a shared szl_khipu organ DAG (immune,
@@ -105,6 +105,115 @@ def _unavailable_tile(name: str, category: str, provenance: dict, err: str) -> d
                  error=err)
 
 
+def _tile_operational_readiness(tile: dict) -> tuple[bool, list[str]]:
+    """Derive runtime readiness from tile evidence without upgrading its label.
+
+    A source can answer while its operator is stopped, its chain is empty, its
+    hardware is unreachable, or its required artifact has not been minted.
+    Reachability is therefore reported separately from operational readiness.
+    """
+    reasons: list[str] = []
+    label = str(tile.get("label") or UNAVAILABLE).upper()
+    status = str(tile.get("status") or "").upper()
+    evidence = tile.get("operational_evidence")
+
+    # Absence of a negative is not positive evidence. Every ready tile must name
+    # its exact bounded predicate and report that predicate satisfied.
+    if not isinstance(evidence, dict):
+        reasons.append("explicit_operational_evidence_missing")
+    else:
+        predicate = evidence.get("predicate")
+        if not isinstance(predicate, str) or not predicate.strip():
+            reasons.append("explicit_operational_predicate_missing")
+        if evidence.get("satisfied") is not True:
+            evidence_reasons = evidence.get("reasons")
+            if isinstance(evidence_reasons, list) and evidence_reasons:
+                reasons.extend(str(reason) for reason in evidence_reasons)
+            else:
+                reasons.append("explicit_operational_evidence_not_satisfied")
+
+    if not tile.get("ok", True):
+        reasons.append("source_unavailable")
+    if label in {UNAVAILABLE, MODELED, ROADMAP, SAMPLE}:
+        reasons.append(f"label_{label.lower()}_is_not_operational_evidence")
+    if any(token in status for token in ("UNAVAILABLE", "IDLE", "EMPTY", "STOPPED")):
+        reasons.append("status_not_running")
+    if tile.get("running") is False:
+        reasons.append("operator_stopped")
+    if tile.get("on_artifact_minted") is False:
+        reasons.append("artifact_not_minted")
+    if tile.get("on_orbit_hardware") is False:
+        reasons.append("hardware_not_present")
+    if "nodes_reachable" in tile and int(tile.get("nodes_reachable") or 0) < 1:
+        reasons.append("no_nodes_reachable")
+    if "reachable_nodes" in tile and int(tile.get("reachable_nodes") or 0) < 1:
+        reasons.append("no_nodes_reachable")
+    if "chain_length" in tile and int(tile.get("chain_length") or 0) < 1:
+        reasons.append("no_chain_entries")
+    if "length" in tile and int(tile.get("length") or 0) < 1:
+        reasons.append("no_chain_entries")
+    if "links_intact" in tile and tile.get("links_intact") is not True:
+        reasons.append("chain_links_not_verified")
+    if "chain_ok" in tile and tile.get("chain_ok") is not True:
+        reasons.append("chain_not_verified")
+    if "survives_redeploy" in tile and tile.get("survives_redeploy") is not True:
+        reasons.append("persistence_not_verified")
+    if tile.get("signature_required") is True and tile.get("signature_verified") is not True:
+        reasons.append("cryptographic_signature_not_verified")
+
+    unique_reasons = list(dict.fromkeys(reasons))
+    return not unique_reasons, unique_reasons
+
+
+def _runtime_signature_readiness(info: dict) -> tuple[bool, list[str], dict]:
+    """Require an observed runtime signer and a cryptographically verified receipt.
+
+    Static policy metadata such as ``signed_receipts=true`` describes an intended
+    contract. It is neither signer health nor proof that a signature was produced
+    and verified, so it cannot make the governance tile operational.
+    """
+    signer = info.get("signer_health") if isinstance(info.get("signer_health"), dict) else {}
+    verification = (info.get("receipt_verification")
+                    if isinstance(info.get("receipt_verification"), dict) else {})
+    method = str(verification.get("method") or "").strip()
+    method_upper = method.upper()
+    signature_count = verification.get("signature_count")
+    try:
+        signature_count = int(signature_count)
+    except (TypeError, ValueError):
+        signature_count = 0
+
+    reasons = []
+    if signer.get("observed_this_process") is not True:
+        reasons.append("signer_health_not_observed")
+    if signer.get("ready") is not True:
+        reasons.append("signer_not_ready")
+    if verification.get("observed_this_process") is not True:
+        reasons.append("receipt_verification_not_observed")
+    if verification.get("cryptographically_verified") is not True:
+        reasons.append("cryptographic_signature_not_verified")
+    if signature_count < 1:
+        reasons.append("verified_signature_missing")
+    if not method or "PLACEHOLDER" in method_upper or method_upper in {"HASH", "HASH_CHAIN"}:
+        reasons.append("cryptographic_verification_method_missing")
+
+    evidence = {
+        "signer_observed_this_process": signer.get("observed_this_process") is True,
+        "signer_ready": signer.get("ready") is True,
+        "signer_identity": signer.get("identity"),
+        "receipt_verification_observed_this_process": (
+            verification.get("observed_this_process") is True
+        ),
+        "cryptographically_verified": (
+            verification.get("cryptographically_verified") is True
+        ),
+        "signature_count": signature_count,
+        "verification_method": method or None,
+    }
+    unique_reasons = list(dict.fromkeys(reasons))
+    return not unique_reasons, unique_reasons, evidence
+
+
 # ---------------------------------------------------------------------------
 # Per-capability tile builders. Each pulls IN-PROCESS from the live surface.
 # ---------------------------------------------------------------------------
@@ -134,6 +243,11 @@ def _tile_energy_operator() -> dict:
         joules_measured_total=measured_total,
         measured_jobs=measured_jobs,
         jobs_done=st.get("jobs_done"),
+        operational_evidence={
+            "predicate": "energy operator reports running=true",
+            "satisfied": running,
+            "reasons": [] if running else ["operator_stopped"],
+        },
     )
 
 
@@ -151,14 +265,16 @@ def _tile_energy_ledger() -> dict:
     if isinstance(head, dict):
         head_digest = head.get("entry_digest") or head.get("digest") \
             or (head.get("receipt") or {}).get("payload_digest")
-    status = (f"OK ({chain_len} signed receipts, links_intact={links_intact})"
+    status = (f"OK ({chain_len} integrity-only receipts, links_intact={links_intact})"
               if chain_len else "IDLE (chain empty — no jobs minted yet)")
     return _tile(
-        "Signed energy ledger", "energy", status=status, label=MEASURED,
+        "Tamper-evident energy ledger", "energy", status=status, label=MEASURED,
         provenance={
             "endpoint": f"{_API}/energy/ledger",
-            "kind": "hash-chained JouleCharge receipt chain",
+            "kind": ("tamper-evident integrity-only JouleCharge hash chain; "
+                     "no cryptographic signature is verified by this surface"),
             "chain_head_digest": head_digest,
+            "signature_status": "NOT_VERIFIED_INTEGRITY_ONLY",
             "single_receipt": f"{_API}/energy/receipt/{{idempotency_key}}",
             # The energy ledger is its OWN hash-chained JouleCharge chain (not a shared
             # szl_khipu organ DAG), so its honest verify surface is the ledger endpoint
@@ -172,6 +288,17 @@ def _tile_energy_ledger() -> dict:
         persistence_label=persistence.get("label"),
         survives_redeploy=survives,
         persistence_note=persistence.get("note"),
+        operational_evidence={
+            "predicate": "non-empty ledger + intact links + verified redeploy persistence",
+            "satisfied": bool(chain_len and links_intact is True and survives),
+            "reasons": [
+                reason for failed, reason in (
+                    (not chain_len, "no_chain_entries"),
+                    (links_intact is not True, "chain_links_not_verified"),
+                    (not survives, "persistence_not_verified"),
+                ) if failed
+            ],
+        },
     )
 
 
@@ -179,7 +306,8 @@ def _tile_energy_provenance() -> dict:
     import szl_energy_provenance as ep
     summ = ep._CHAIN.summary()
     length = summ.get("length", 0)
-    status = (f"VERIFIED ({length} tamper-evident receipts)" if length
+    verify = summ.get("verify", {}) or {}
+    status = (f"INTEGRITY-VERIFIED ({length} tamper-evident receipts)" if length
               else "EMPTY (no receipts this process)")
     return _tile(
         "Energy provenance chain", "provenance", status=status, label=MEASURED,
@@ -188,12 +316,24 @@ def _tile_energy_provenance() -> dict:
             "kind": "tamper-evident hash-linked + Bekenstein-gated chain",
             "head_hash": summ.get("head_hash"),
             "link_rule": summ.get("link_rule"),
+            "signature_status": "NOT_VERIFIED_INTEGRITY_ONLY",
             # Its OWN Bekenstein-gated chain (not a shared szl_khipu organ) -> honest
             # verify surface is its own endpoint, re-walked. Not pointed at /khipu/verify.
             "verify": f"{_API}/energy/provenance",
         },
         length=length,
-        chain_status=summ.get("status"),
+        integrity_chain_status=summ.get("status"),
+        verification_scope="content and hash-link integrity only; authorship not verified",
+        operational_evidence={
+            "predicate": "non-empty provenance chain + computed chain verification",
+            "satisfied": bool(length and verify.get("ok") is True),
+            "reasons": [
+                reason for failed, reason in (
+                    (not length, "no_chain_entries"),
+                    (verify.get("ok") is not True, "chain_not_verified"),
+                ) if failed
+            ],
+        },
     )
 
 
@@ -219,6 +359,11 @@ def _tile_uds_bundle() -> dict:
             "sbom": "CycloneDX / SPDX in-toto attestation",
             "backing_module": backing,
         },
+        operational_evidence={
+            "predicate": "a concrete UDS attestation is independently verified at runtime",
+            "satisfied": False,
+            "reasons": ["runtime_attestation_receipt_not_observed"],
+        },
     )
 
 
@@ -243,6 +388,11 @@ def _tile_orbital() -> dict:
         # reachable_nodes is REAL-PROBE-ONLY and MUST be 0 — no orbital hardware to probe.
         reachable_nodes=reachable,
         note="every orbital node is modeled:true / reachable:false; a MODELED orbital joule is NEVER MEASURED",
+        operational_evidence={
+            "predicate": "at least one on-orbit hardware node is positively reachable",
+            "satisfied": False,
+            "reasons": ["hardware_not_present"],
+        },
     )
 
 
@@ -271,6 +421,11 @@ def _tile_compute_fabric() -> dict:
         # reachable / gpu_reachable are REAL-PROBE-ONLY facts.
         nodes_reachable=reachable_n,
         gpu_reachable=gpu_reachable,
+        operational_evidence={
+            "predicate": "at least one sovereign GPU node passes the live reachability probe",
+            "satisfied": gpu_reachable > 0,
+            "reasons": [] if gpu_reachable > 0 else ["no_sovereign_gpu_reachable"],
+        },
     )
 
 
@@ -281,35 +436,50 @@ def _tile_governance() -> dict:
         import szl_restraint as rs
     info = rs.info()
     doctrine = info.get("doctrine", {}) or {}
+    crypto_ready, crypto_reasons, crypto_evidence = _runtime_signature_readiness(info)
+    status = ("OK (runtime signer healthy; receipt signature cryptographically verified)"
+              if crypto_ready else
+              "DEGRADED (doctrine loaded; runtime signer/receipt verification not observed)")
     return _tile(
-        "Governance / restraint", "governance", status="OK (codified doctrine + signed receipts)",
+        "Governance / restraint", "governance", status=status,
         label=MEASURED,
         provenance={
             "endpoint": f"{_API}/restraint/info",
-            "kind": "codified restraint ladder; each decision -> a signed DSSE receipt",
+            "kind": ("codified restraint policy metadata; operational status additionally "
+                     "requires observed signer health and cryptographic receipt verification"),
             "doctrine_version": doctrine.get("version"),
             "kernel_commit": doctrine.get("kernel_commit"),
         },
-        signed_receipts=doctrine.get("signed_receipts"),
+        signed_receipts_declared=doctrine.get("signed_receipts"),
+        signer_health=crypto_evidence,
+        signature_required=True,
+        signature_verified=crypto_ready,
         runtime_cdn=doctrine.get("runtime_cdn"),
         lambda_=doctrine.get("lambda"),
+        operational_evidence={
+            "predicate": ("runtime signer health observed + at least one receipt signature "
+                          "cryptographically verified this process"),
+            "satisfied": crypto_ready,
+            "reasons": crypto_reasons,
+        },
     )
 
 
 def _concept_tile_inference_provenance() -> dict:
     """#1 frontier play — composite inference-provenance receipt (the inference-side C2PA).
 
-    LIVE capability, surfaced by READING the shared provenance Khipu chain — this tile
-    NEVER mints a receipt. The capstone surface szl_provenance_receipt composes ONE signed
-    Khipu envelope binding every guarantee for a single governed action (immune verdict +
+    Capability surfaced by READING the shared provenance Khipu chain — this tile
+    NEVER mints a receipt. The capstone surface szl_provenance_receipt composes ONE
+    tamper-evident Khipu envelope binding fields for a single governed action (immune verdict +
     PAC-Bayes bound + MEASURED/MODELED/SAMPLE energy label + governed model identity + Lean
-    backing) — but a receipt is signed ONLY when a real governed action POSTs
-    /provenance/receipt, never just because someone loaded this page. Here we READ the
+    backing). It becomes signed evidence only when a cryptographic DSSE signature is observed
+    and verified. A real governed action POSTs /provenance/receipt; loading this page never
+    creates evidence. Here we READ the
     chain head (depth + most-recent composite digest, if any) and re-verify chain
     integrity, so the tile honestly DESCRIBES the capability and points to where the real
     artifacts live (/provenance/receipt + the energy ledger) without growing the chain.
     Honesty held: a GET does not fabricate or mint a composite; if no composite exists yet
-    the tile says so honestly (ROADMAP, awaiting first real action)."""
+    the tile is UNAVAILABLE, awaiting a real governed write."""
     import szl_khipu
     import szl_provenance_receipt as pr
 
@@ -320,30 +490,61 @@ def _concept_tile_inference_provenance() -> dict:
     head = dag.head()
     # Most-recent composite digest already on the chain (a READ, never a mint).
     last_composite = None
+    last_composite_receipt = None
     for r in reversed(dag.tail(depth or 1)):
         if r.get("action") == "provenance.composite":
             last_composite = r.get("digest")
+            last_composite_receipt = r
             break
 
     minted = last_composite is not None
-    if minted:
-        status = (f"LIVE ({depth} signed receipts on the provenance chain; latest composite "
-                  "binds immune verdict + PAC-Bayes bound + energy label + governed model "
-                  "identity + Lean backing). Receipts mint ONLY on a real POST, never on a GET.")
+    signature = ((last_composite_receipt or {}).get("signature")
+                 if last_composite_receipt else None)
+    verification = ((last_composite_receipt or {}).get("cryptographic_verification")
+                    if isinstance((last_composite_receipt or {}).get(
+                        "cryptographic_verification"), dict) else {})
+    verification_method = str(verification.get("method") or "").strip()
+    try:
+        verified_signature_count = int(verification.get("signature_count") or 0)
+    except (TypeError, ValueError):
+        verified_signature_count = 0
+    signature_verified = bool(
+        minted
+        and verification.get("observed_this_process") is True
+        and verification.get("verified") is True
+        and verified_signature_count > 0
+        and verification_method
+        and "PLACEHOLDER" not in verification_method.upper()
+        and signature not in (None, "", "DSSE_PLACEHOLDER")
+    )
+    if minted and signature_verified:
+        status = (f"LIVE ({depth} receipts on the provenance chain; latest composite has an "
+                  "observed, cryptographically verified signature and binds immune verdict + "
+                  "PAC-Bayes bound + energy label + governed model identity + Lean backing).")
         label = MEASURED
-        note = ("inference-side C2PA, LIVE: each composite is a single signed Khipu envelope "
-                "composing the REAL immune verdict, the PAC-Bayes bound (ROADMAP Lean), the "
+        note = ("inference-side composite, LIVE: the latest Khipu envelope has an observed, "
+                "cryptographically verified signature and composes the REAL immune verdict, "
+                "the PAC-Bayes bound (ROADMAP Lean), the "
                 "MEASURED/MODELED/SAMPLE energy label, the governed model identity, and the "
-                "exact Lean backing. Each part KEEPS its own label; no label is upgraded; the "
-                "signature is the honest DSSE_PLACEHOLDER. This tile READS the chain — it does "
+                "exact Lean backing. Each part KEEPS its own label; no label is upgraded. "
+                "This tile READS the chain — it does "
                 "NOT mint a receipt per page view. POST the endpoint to mint one for a real "
                 "action, then GET it back by digest.")
+    elif minted:
+        status = (f"INTEGRITY-ONLY ({depth} hash-chained receipts; latest composite exists, "
+                  "but no cryptographically verified DSSE signature was observed)")
+        label = UNAVAILABLE
+        note = ("the composite is content-addressed and its Khipu prev-links re-walk, but "
+                "DSSE_PLACEHOLDER is not a signature and proves no authorship. The signed "
+                "composite capability remains operationally blocked until real DSSE evidence "
+                "is verified this process.")
     else:
-        status = ("ROADMAP (capability wired; no composite minted yet this process — a signed "
-                  "composite is created ONLY when a real governed action POSTs the endpoint)")
-        label = ROADMAP
-        note = ("inference-side C2PA capability is wired but no composite has been minted in "
-                "this process yet. A signed composite is created ONLY on a real POST to "
+        status = ("UNAVAILABLE (capability wired, but no composite receipt has been observed "
+                  "in this process; only a real governed POST can mint one)")
+        label = UNAVAILABLE
+        note = ("inference-side C2PA capability is reachable but not operationally evidenced: "
+                "no composite has been minted in "
+                "this process yet. A composite is created ONLY on a real POST to "
                 "/provenance/receipt (immune verdict + PAC-Bayes bound + energy label + "
                 "governed model identity + Lean backing) — never fabricated, never minted by "
                 "loading this manifest.")
@@ -352,10 +553,9 @@ def _concept_tile_inference_provenance() -> dict:
         "Composite inference-provenance receipt", "frontier-concept",
         status=status, label=label,
         provenance={
-            "kind": "composite composed in-process by CALLING the live surfaces and signed "
-                    "into the shared provenance Khipu chain (signature = honest "
-                    "DSSE_PLACEHOLDER, cosign founder-gated); this manifest tile READS the "
-                    "chain head and NEVER mints a receipt per page view",
+            "kind": ("composite composed in-process and recorded in a tamper-evident Khipu "
+                     "hash chain; DSSE_PLACEHOLDER is integrity-only metadata, not a "
+                     "cryptographic signature; this manifest READS and never mints"),
             "endpoint": f"{_API}/provenance/receipt",
             # Composite receipts live in the shared szl_khipu `provenance` organ, so a
             # judge can re-verify a composite digest TWO honest ways: the composite
@@ -368,16 +568,36 @@ def _concept_tile_inference_provenance() -> dict:
             "latest_composite_digest": last_composite,
             "chain_head": head,
             "chain_verified": chain.get("ok"),
+            "signature_status": ("CRYPTOGRAPHICALLY_VERIFIED" if signature_verified else
+                                 "NOT_VERIFIED_INTEGRITY_ONLY"),
+            "signature_verification_method": verification_method or None,
             "composes_measured": f"{_API}/immune/verdict (REAL fail-closed gate) + the "
                                  "MEASURED energy joule-truth path",
-            "composes_roadmap": f"{_API}/materials/certify (PAC-Bayes bound; Lean SORRY/ROADMAP)",
+            "open_dependencies": f"{_API}/materials/certify (PAC-Bayes/Lean evidence must "
+                                 "retain the status reported by that dependency)",
         },
         # READ facts straight off the chain — this tile mints nothing on a GET.
         on_artifact_minted=minted,
         composite_digest=last_composite,
         chain_ok=chain.get("ok"),
         chain_length=depth,
+        signature_required=True,
+        signature_verified=signature_verified,
         note=note,
+        operational_evidence={
+            "predicate": ("a composite exists, its Khipu integrity chain verifies, and its "
+                          "DSSE signature is cryptographically verified this process"),
+            "satisfied": bool(minted and depth > 0 and chain.get("ok") is True
+                              and signature_verified),
+            "reasons": [
+                reason for failed, reason in (
+                    (not minted, "artifact_not_minted"),
+                    (depth < 1, "no_chain_entries"),
+                    (chain.get("ok") is not True, "chain_not_verified"),
+                    (not signature_verified, "cryptographic_signature_not_verified"),
+                ) if failed
+            ],
+        },
     )
 
 
@@ -386,7 +606,7 @@ def _concept_tile_inference_provenance() -> dict:
 _TILE_SPECS: list[tuple[Callable[[], dict], str, str, dict]] = [
     (_tile_energy_operator, "Energy operator", "energy",
      {"endpoint": f"{_API}/energy/operator/status"}),
-    (_tile_energy_ledger, "Signed energy ledger", "energy",
+    (_tile_energy_ledger, "Tamper-evident energy ledger", "energy",
      {"endpoint": f"{_API}/energy/ledger"}),
     (_tile_energy_provenance, "Energy provenance chain", "provenance",
      {"endpoint": f"{_API}/energy/provenance"}),
@@ -430,7 +650,8 @@ def _build_manifest() -> dict:
         tiles.append(tile if tile is not None
                      else _unavailable_tile(name, category, prov, err or "unknown error"))
 
-    # #1 frontier play — always present, always ROADMAP, never a fabricated artifact.
+    # Composite capability — always present, but UNAVAILABLE until a real write has
+    # minted an artifact. A manifest read never creates operational evidence.
     concept, c_err = _safe(_concept_tile_inference_provenance)
     if concept is None:  # pragma: no cover — the concept tile is pure data
         concept = _unavailable_tile("Composite inference-provenance receipt",
@@ -441,47 +662,79 @@ def _build_manifest() -> dict:
     for t in tiles:
         label_counts[t["label"]] = label_counts.get(t["label"], 0) + 1
     degraded = [t["name"] for t in tiles if not t.get("ok", True)]
+    reachable = [t["name"] for t in tiles if t.get("ok", True)]
+    readiness_rows = []
+    for tile in tiles:
+        ready, reasons = _tile_operational_readiness(tile)
+        readiness_rows.append({"name": tile["name"], "ready": ready, "reasons": reasons})
+    blocked = [row for row in readiness_rows if not row["ready"]]
+    all_sources_reachable = len(degraded) == 0
+    operationally_ready = not blocked and bool(tiles)
 
     return {
         "ok": True,
         "endpoint": "frontier/manifest",
         "service": "a11oy.frontier.manifest",
         "what": ("one honest roll-up of the SZL governed-provenance ecosystem — every "
-                 "capability as a tile with its MEASURED/MODELED/ROADMAP/SAMPLE label and "
+                 "capability as a tile with its own honesty label and "
                  "a provenance pointer. Composed live, in-process, from the wired surfaces."),
         "doctrine": (
             "v11: REAL composed data only. No label is upgraded (orbital stays MODELED, "
             "ROADMAP stays ROADMAP). reachable/running/survives_redeploy are REAL-PROBE-ONLY "
             "and read straight from the live surfaces. A down sub-source yields an honest "
-            "UNAVAILABLE tile, never a fabricated OK. The #1 frontier composite receipt is a "
-            "ROADMAP concept that names its parts — no composite artifact is minted. "
+            "UNAVAILABLE tile, never a fabricated OK. The composite receipt remains "
+            "UNAVAILABLE until a real governed write has minted an artifact. "
             "Λ = Conjecture 1."
         ),
         "universal_verifier": {
-            "what": "judge-facing audit layer: paste ANY receipt digest from ANY shared "
+            "what": "judge-facing integrity layer: paste ANY receipt digest from ANY shared "
                     "szl_khipu organ (immune, materials, kverify, provenance, sda, "
-                    "nemo_agents) and get an INDEPENDENT, COMPUTED PASS|FAIL|NOT_FOUND",
+                    "nemo_agents) and get a COMPUTED hash-chain PASS|FAIL|NOT_FOUND",
             "verify_post": _KHIPU_VERIFY,
             "verify_link": _KHIPU_VERIFY_PATH,
             "organs": _KHIPU_ORGANS,
-            "method": "SHA3-256 seal recompute (the exact szl_khipu sealing scheme) + "
-                      "prev-link re-walk to genesis; digest_matches + "
-                      "chain_to_genesis_verified are COMPUTED, never asserted",
-            "signature_status": "DSSE_PLACEHOLDER (cosign founder-gated; never faked)",
-            "khipu_kind": "Conjecture 2 (chain INTEGRITY real; BFT/consensus is the conjecture)",
+            "method": "integrity-only SHA3-256 seal recompute + prev-link re-walk to genesis; "
+                      "digest_matches + chain_to_genesis_verified are COMPUTED, never "
+                      "asserted; this does not verify authorship",
+            "signature_status": ("NOT_VERIFIED_INTEGRITY_ONLY; DSSE_PLACEHOLDER is not a "
+                                 "cryptographic signature"),
+            "khipu_kind": ("tamper-evident integrity chain only; authorship remains blocked "
+                           "until a real DSSE signature is verified; BFT/consensus is "
+                           "Conjecture 2"),
         },
         "labels_legend": {
-            "MEASURED": "real measured/shipped capability (e.g. signed joule receipts, REAL probes)",
+            "MEASURED": ("real measured/shipped capability (e.g. tamper-evident joule "
+                         "receipts, REAL probes); MEASURED never implies signed"),
             "MODELED": "design artifact derived from a real measurement (e.g. orbital joules from ground coeff)",
             "ROADMAP": "named forward work; no fabricated artifact",
             "SAMPLE": "illustrative sample value, never billable/live",
-            "UNAVAILABLE": "sub-source down right now — reported honestly, not faked",
+            "UNAVAILABLE": "source, dependency, or required artifact unavailable right now",
         },
         "summary": {
             "tiles": len(tiles),
             "label_counts": label_counts,
             "degraded_tiles": degraded,
-            "all_sources_live": len(degraded) == 0,
+            "source_reachability": {
+                "state": "REACHABLE" if all_sources_reachable else "DEGRADED",
+                "all_sources_reachable": all_sources_reachable,
+                "reachable_tiles": reachable,
+                "unavailable_tiles": degraded,
+            },
+            "operational_readiness": {
+                "state": "READY" if operationally_ready else "NOT_READY",
+                "ready": operationally_ready,
+                "ready_tiles": [row["name"] for row in readiness_rows if row["ready"]],
+                "blocked_tiles": blocked,
+            },
+            # Deprecated for old clients. This value is intentionally stricter than source
+            # reachability and cannot be true while a required tile is stopped, unminted,
+            # modeled, sampled, or unavailable.
+            "all_sources_live": operationally_ready,
+            "all_sources_live_compatibility": {
+                "deprecated": True,
+                "meaning": "legacy alias for operational_readiness.ready; not source reachability",
+                "value": operationally_ready,
+            },
         },
         "capabilities": tiles,
         "timestamp_utc": _now_iso(),
@@ -574,7 +827,7 @@ if __name__ == "__main__":
 
     # 4) the #1 frontier composite tile READS the provenance chain; it NEVER mints a
     #    receipt on a manifest GET. A fresh process has an empty provenance chain, so the
-    #    tile is honestly ROADMAP / no-artifact; building the manifest must not grow it.
+    #    tile is honestly UNAVAILABLE / no-artifact; building the manifest must not grow it.
     import szl_khipu as _kh
     import szl_provenance_receipt as _pr
     _prov = _kh.get_dag(_pr._KHIPU_ORGAN, ns="a11oy")
@@ -584,10 +837,11 @@ if __name__ == "__main__":
     assert _after == _before, (
         f"manifest GET must NOT mint a provenance receipt (chain grew {_before}->{_after})")
     concept = next(t for t in tiles if t["category"] == "frontier-concept")
-    assert concept["label"] in (ROADMAP, MEASURED), concept["label"]
-    # On a fresh process (empty chain) the tile is honestly ROADMAP with no artifact.
+    assert concept["label"] in (UNAVAILABLE, MEASURED), concept["label"]
+    # On a fresh process (empty chain) the tile is honestly UNAVAILABLE with no artifact.
     if _before == 0:
-        assert concept["label"] == ROADMAP, "empty chain -> honest ROADMAP, no fabricated artifact"
+        assert concept["label"] == UNAVAILABLE, \
+            "empty chain -> honest UNAVAILABLE, no fabricated artifact"
         assert concept.get("on_artifact_minted") is False, "no composite minted by a GET"
         assert concept.get("composite_digest") is None, "no digest fabricated on a GET"
     assert concept["provenance"].get("chain_verified") is True, "provenance chain must verify"
@@ -596,6 +850,8 @@ if __name__ == "__main__":
 
     # 5) labels legend + summary present; degraded tiles (if any) reported honestly
     assert "labels_legend" in m and "summary" in m
+    assert "source_reachability" in m["summary"]
+    assert "operational_readiness" in m["summary"]
     print(f"[5] summary: {_json.dumps(m['summary'])}")
 
     print("\n--- tiles (name / label / status) ---")
@@ -603,5 +859,3 @@ if __name__ == "__main__":
         print(f"  - {t['name']:38s} {t['label']:11s} {t['status']}")
     print("\nok:true checks:5")
     _sys.exit(0)
-
-

szl_gpu_quant.py

@@ -30,10 +30,10 @@ HONESTY SPINE (doctrine v11 — the non-negotiable part of this build):
     (cuML LedoitWolf + cuPy eigh + giotto-tda / Ripser++) is labeled ROADMAP. GPU
     reachability and dependency imports are readiness only; MEASURED requires a distinct
     accelerated path plus device/kernel/timing execution evidence.
-  * Every receipt is SIGNED via szl_dsse.sign_payload (REAL ECDSA when the cosign key
-    is present in the runtime; an explicit UNSIGNED honesty marker otherwise — never a
-    fabricated signature). The label SAMPLE_SIGNAL | NOT_LIVE | NO_BACKTEST_VALIDATED is
-    embedded in the signed payload so the honesty claim is self-verifying.
+  * Every receipt is wrapped by szl_dsse.sign_payload (verified ECDSA when the cosign key
+    is present in the runtime; explicitly UNSIGNED otherwise — never a fabricated
+    signature). The label SAMPLE_SIGNAL | NOT_LIVE | NO_BACKTEST_VALIDATED is embedded
+    in the content-addressed payload and its signature state is reported separately.
   * No fabricated metric. No live-trading claim. No backtest claim. cuML speedups are
     cited to NVIDIA/STAC docs, never asserted as SZL-measured.
 
@@ -41,34 +41,29 @@ Routes (NEW; never collide):
   GET  /api/{ns}/v1/quant/pca        — Layer 1 PCA-Risk (LW + MP) on a SAMPLE universe
   GET  /api/{ns}/v1/quant/tda        — Layer 2 TDA fracture score f_t, z_t, Betti β0/β1
   GET  /api/{ns}/v1/quant/kelly      — Layer 3 HJB-Kelly weights w* with σ²_eff
-  GET  /api/{ns}/v1/quant/pipeline   — full 3-layer pass + ONE signed SAMPLE receipt
+  GET  /api/{ns}/v1/quant/pipeline   — full 3-layer pass + ONE DSSE-bearing SAMPLE receipt
   GET  /api/{ns}/v1/quant/tiers      — 2-GPU serve tier panel (TP=2 / role-split / NIM cloud)
-  GET  /api/{ns}/v1/quant/verify-claims — cited external reports vs verified SZL receipts
+  GET  /api/{ns}/v1/quant/verify-claims — NVIDIA datasheet vs SZL-MEASURED (honest, empty/ROADMAP)
   GET  /quant                        — unified mobile-first "Quant Engine" tab (0 CDN)
 
 Pure stdlib. Defensive: a compute failure NEVER raises out of a handler.
 """
 from __future__ import annotations
 
+import base64 as _base64
 import hashlib as _hashlib
-import html as _html_lib
 import json as _json
 import math as _math
 import os as _os
+from pathlib import Path as _Path
 import random as _random
 import time as _time
 from datetime import datetime, timezone
 
-from szl_quant_claims import resolved_claims as _resolved_quant_claims
-
-try:
-    import szl_formula_registry as _formula_registry
-except Exception:  # pragma: no cover - missing registry stays explicit
-    _formula_registry = None
-
 # --- signed receipts: the SINGLE source of truth (never fabricate a signature) ----
 try:
     from szl_dsse import sign_payload as _sign_payload  # REAL ECDSA when key present
+    from szl_dsse import verify_envelope as _verify_envelope
     _SIGN_AVAILABLE = True
 except Exception:  # pragma: no cover — defensive; honest unsigned fallback below
     _SIGN_AVAILABLE = False
@@ -87,6 +82,9 @@ except Exception:  # pragma: no cover — defensive; honest unsigned fallback be
                         "no signature fabricated."),
         }
 
+    def _verify_envelope(_envelope):  # type: ignore
+        return {"verified": False, "reason": "szl_dsse verifier is unavailable"}
+
 _QUANT_PAYLOAD_TYPE = "application/vnd.szl.quant.receipt+json"
 
 # --- optional acceleration probes (honest GPU-path labels) ------------------------
@@ -166,38 +164,12 @@ def _compute_backend() -> dict:
     }
 
 
-def _formula_doctrine() -> dict:
-    """Read the quant page's doctrine from the verified formula registry."""
-    if _formula_registry is None:
-        return {
-            "locked_proven": [], "locked_count": 0, "corpus": "UNAVAILABLE",
-            "kernel_commit": "UNAVAILABLE", "registry_digest": None,
-            "registry_signature": "UNAVAILABLE", "registry_status": "UNAVAILABLE",
-        }
-    try:
-        document = _formula_registry.load_registry(verify=True)
-        payload = document["payload"]
-        return {
-            "locked_proven": list(_formula_registry.LOCKED_PROVEN_IDS),
-            "locked_count": _formula_registry.LOCKED_PROVEN_COUNT,
-            "corpus": "registry-crosswalk (non-exhaustive)",
-            "kernel_commit": payload["locked_kernel_commit_prefix"],
-            "registry_digest": document["registry_digest"]["value"],
-            "registry_signature": document["signature"]["status"],
-            "registry_status": "VERIFIED",
-        }
-    except Exception as exc:  # fail closed; never fall back to stale doctrine
-        return {
-            "locked_proven": [], "locked_count": 0, "corpus": "UNAVAILABLE",
-            "kernel_commit": "UNAVAILABLE", "registry_digest": None,
-            "registry_signature": "UNAVAILABLE",
-            "registry_status": "UNAVAILABLE: " + type(exc).__name__,
-        }
-
-
 DOCTRINE = {
     "version": "v11",
-    **_formula_doctrine(),
+    "locked_proven": ["F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22"],
+    "locked_count": 8,
+    "corpus": "749/14/163",
+    "kernel_commit": "c7c0ba17",
     "lambda": "Conjecture 1 (advisory floor; uniqueness machine-checked FALSE unconditionally; NOT a theorem)",
     "slsa": "L1 honest / L2 attested (.att emitted, not independently verified) / L3 roadmap",
 }
@@ -698,10 +670,10 @@ def layer3_hjb_kelly(l1=None, l2=None, gamma=0.5, kappa=1.0, stress=False):
 
 
 # =====================================================================================
-# FULL PIPELINE -> ONE signed SAMPLE receipt.
+# FULL PIPELINE -> ONE DSSE-bearing SAMPLE receipt.
 # =====================================================================================
 def run_pipeline(stress=False, gamma=0.5, kappa=1.0) -> dict:
-    """Full 3-layer pass + a single SIGNED SAMPLE receipt (DSSE over canonical JSON)."""
+    """Full 3-layer pass plus a DSSE envelope whose signature state is explicit."""
     returns = _sample_returns(stress=stress)
     l1 = layer1_pca_risk(returns=returns, stress=stress)
     l2 = layer2_tda_fracture(returns=returns, stress=stress)
@@ -847,37 +819,403 @@ def tiers_panel() -> dict:
 
 
 # =====================================================================================
-# VERIFY-THE-CLAIMS panel: external reports vs SZL-MEASURED (honest; empty/ROADMAP).
+# VERIFY-THE-CLAIMS panel: NVIDIA datasheet vs SZL-MEASURED (honest; empty/ROADMAP).
+# =====================================================================================
+def _legacy_verify_claims_panel() -> dict:
+    """Side-by-side NVIDIA datasheet numbers vs SZL-MEASURED (signed). Honest: SZL columns
+    are empty/ROADMAP until we actually measure on OUR harness. NEVER print the datasheet
+    number as if it were ours."""
+    reachable = _gpu_reachable()
+    rows = [
+        {"claim": "Nemotron speedup vs prior frontier", "nvidia_datasheet": "up to 5×",
+         "szl_measured": None, "szl_label": "ROADMAP",
+         "how": "OUR τ-bench + J/token harness on the NIM-routed Ultra tier"},
+        {"claim": "Reasoning/accuracy uplift", "nvidia_datasheet": "+30%",
+         "szl_measured": None, "szl_label": "ROADMAP",
+         "how": "OUR τ-bench score (MEASURED-by-SZL), signed receipt"},
+        {"claim": "Benchmark accuracy", "nvidia_datasheet": "91%",
+         "szl_measured": None, "szl_label": "ROADMAP",
+         "how": "OUR eval set, ECE/Brier calibrated"},
+        {"claim": "Long-context retrieval", "nvidia_datasheet": "1M-token retrieval",
+         "szl_measured": None, "szl_label": "ROADMAP",
+         "how": "OUR needle-in-haystack probe, signed"},
+        {"claim": "cuML PCA speedup (quant Layer 1)", "nvidia_datasheet": "10–50× (S&P 500 scale); ~100× genomic",
+         "szl_measured": None, "szl_label": "ROADMAP",
+         "how": "OUR Layer-1 LedoitWolf on the sovereign GPU vs CPU fallback, signed J/bar"},
+        {"claim": "Ripser++ persistence (quant Layer 2)", "nvidia_datasheet": "up to 30× vs CPU Ripser",
+         "szl_measured": None, "szl_label": "ROADMAP",
+         "how": "OUR Layer-2 VR persistence on the sovereign GPU, signed bar latency"},
+    ]
+    return {
+        "service": "verify-the-claims",
+        "doctrine": DOCTRINE["version"],
+        "summary": ("EMPTY / ROADMAP until SZL measures on its own harness — this is the differentiator: "
+                    "we publish SZL-MEASURED (signed), never the datasheet number."),
+        "gpu_reachable": reachable,
+        "rows": rows,
+        "honesty": ("The 'NVIDIA datasheet' column is the vendor's published claim (cited, not endorsed). "
+                    "The 'SZL-MEASURED' column stays null/ROADMAP until we run OUR τ-bench + J/token + "
+                    "J/bar harness and SIGN the result. measured > datasheet, always. Never fabricated."),
+        "citations": [CITATIONS["rapids_cuml"], CITATIONS["ripserpp"]],
+        "computed_at": _now_iso(),
+    }
+
+
+# =====================================================================================
+# Receipt-gated local verification. The legacy static panel above is retained only as
+# historical code; this definition is authoritative for routes and the UI.
 # =====================================================================================
+_QUANT_RECEIPT_SCHEMA = "szl.quant-live-benchmark-receipt.v1"
+_QUANT_RECEIPT_SCOPE = "bounded local execution; not a replication of vendor-scale claims"
+_QUANT_RECEIPT_PAYLOAD_TYPE = "application/vnd.szl.quant-live-benchmark+json"
+
+
+def _dsse_signature_state(dsse):
+    """Classify a DSSE envelope from cryptographic evidence, not its flag."""
+    if not isinstance(dsse, dict):
+        return "INVALID_SIGNATURE"
+    signatures = dsse.get("signatures")
+    if not isinstance(signatures, list):
+        return "INVALID_SIGNATURE"
+    if dsse.get("signed") is True:
+        verdict = _verify_envelope(dsse)
+        if isinstance(verdict, dict) and verdict.get("verified") is True:
+            return "SIGNED_VERIFIED"
+        return "INVALID_SIGNATURE"
+    if signatures:
+        return "INVALID_SIGNATURE"
+    return "UNSIGNED_CONTENT_ADDRESSED"
+
+
+def _finite_number(value, field, minimum=None, maximum=None):
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not _math.isfinite(float(value)):
+        raise ValueError("%s must be a finite number" % field)
+    number = float(value)
+    if minimum is not None and number < minimum:
+        raise ValueError("%s is below its allowed minimum" % field)
+    if maximum is not None and number > maximum:
+        raise ValueError("%s exceeds its allowed maximum" % field)
+    return number
+
+
+def _bounded_int(value, field, minimum=0, maximum=1_000_000):
+    if isinstance(value, bool) or not isinstance(value, int) or not minimum <= value <= maximum:
+        raise ValueError("%s must be an integer between %s and %s" % (field, minimum, maximum))
+    return value
+
+
+def _aware_timestamp(value, field):
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError("%s missing" % field)
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ValueError("%s is not an ISO-8601 timestamp" % field) from exc
+    if parsed.tzinfo is None or parsed.utcoffset() is None:
+        raise ValueError("%s must include a timezone" % field)
+    return parsed.astimezone(timezone.utc)
+
+
+def _validate_model_identity(identity, measurement, role):
+    if not isinstance(identity, dict):
+        raise ValueError("%s identity missing" % role)
+    if not isinstance(measurement, dict):
+        raise ValueError("%s measurement missing" % role)
+    requested = identity.get("requested_model")
+    if not isinstance(requested, str) or not requested.strip() or requested != measurement.get("model"):
+        raise ValueError("%s identity does not match measured model" % role)
+    manifest_hash = identity.get("show_response_sha256")
+    if not isinstance(manifest_hash, str) or len(manifest_hash) != 64:
+        raise ValueError("%s identity manifest hash missing" % role)
+    try:
+        int(manifest_hash, 16)
+    except ValueError as exc:
+        raise ValueError("%s identity manifest hash is not SHA-256" % role) from exc
+    lineage = identity.get("base_lineage")
+    if not isinstance(lineage, dict) or not any(
+        isinstance(lineage.get(key), str) and lineage.get(key).strip()
+        for key in ("base_ref", "parent_model", "base_digest")
+    ):
+        raise ValueError("%s base lineage missing" % role)
+    wall_ms = identity.get("show_wall_ms")
+    if wall_ms is not None:
+        _finite_number(wall_ms, "%s identity show_wall_ms" % role, 0.0)
+    return manifest_hash.lower()
+
+
+def _validate_model_measurement(measurement, role):
+    if not isinstance(measurement, dict):
+        raise ValueError("%s measurement missing" % role)
+    exact = measurement.get("exact_match")
+    retrieval = measurement.get("bounded_retrieval")
+    runtime = measurement.get("runtime")
+    if not isinstance(exact, dict) or not isinstance(retrieval, dict) or not isinstance(runtime, dict):
+        raise ValueError("%s semantic measurement sections missing" % role)
+    total = _bounded_int(exact.get("tasks_total"), "%s tasks_total" % role, 1, 10_000)
+    passed = _bounded_int(exact.get("tasks_passed"), "%s tasks_passed" % role, 0, total)
+    accuracy = _finite_number(exact.get("accuracy_pct"), "%s accuracy_pct" % role, 0.0, 100.0)
+    expected_accuracy = 100.0 * passed / total
+    if abs(accuracy - expected_accuracy) > 0.001:
+        raise ValueError("%s accuracy_pct is inconsistent with pass counts" % role)
+    probes_total = _bounded_int(retrieval.get("probes_total"), "%s probes_total" % role, 1, 10_000)
+    _bounded_int(retrieval.get("probes_passed"), "%s probes_passed" % role, 0, probes_total)
+    _bounded_int(
+        retrieval.get("max_prompt_eval_tokens"), "%s max_prompt_eval_tokens" % role, 0, 10_000_000
+    )
+    _bounded_int(runtime.get("requests"), "%s runtime requests" % role, 1, 100_000)
+    latency = _finite_number(runtime.get("p50_wall_ms"), "%s p50_wall_ms" % role, 0.000001)
+    tps = runtime.get("p50_tokens_per_second")
+    if tps is not None:
+        _finite_number(tps, "%s p50_tokens_per_second" % role, 0.000001)
+    return {"accuracy": accuracy, "latency": latency}
+
+
+def _validate_cpu_reference(reference, field):
+    if not isinstance(reference, dict):
+        raise ValueError("%s missing" % field)
+    _bounded_int(reference.get("repeats"), "%s repeats" % field, 1, 20)
+    minimum = _finite_number(reference.get("min_ms"), "%s min_ms" % field, 0.0)
+    p50 = _finite_number(reference.get("p50_ms"), "%s p50_ms" % field, 0.0)
+    maximum = _finite_number(reference.get("max_ms"), "%s max_ms" % field, 0.0)
+    if minimum > p50 or p50 > maximum:
+        raise ValueError("%s latency order is inconsistent" % field)
+    if reference.get("compute_path") != "CPU_REFERENCE":
+        raise ValueError("%s is not an explicit CPU reference" % field)
+    return p50
+
+
+def _validate_quant_receipt(envelope):
+    if not isinstance(envelope, dict):
+        raise ValueError("receipt envelope missing")
+    receipt = envelope.get("receipt")
+    if not isinstance(receipt, dict):
+        raise ValueError("receipt object missing")
+    if receipt.get("schema_version") != _QUANT_RECEIPT_SCHEMA:
+        raise ValueError("unsupported receipt schema")
+    if receipt.get("measurement_class") != "MEASURED":
+        raise ValueError("receipt is not a completed MEASURED execution")
+    if receipt.get("scope") != _QUANT_RECEIPT_SCOPE:
+        raise ValueError("receipt scope is not the bounded local harness")
+
+    claimed_digest = receipt.get("content_sha256")
+    unsigned_body = dict(receipt)
+    unsigned_body.pop("content_sha256", None)
+    observed_digest = _hashlib.sha256(
+        _json.dumps(unsigned_body, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    ).hexdigest()
+    if claimed_digest != observed_digest:
+        raise ValueError("content digest mismatch")
+
+    started = _aware_timestamp(receipt.get("started_at"), "started_at")
+    completed = _aware_timestamp(receipt.get("completed_at"), "completed_at")
+    now = datetime.now(timezone.utc)
+    if completed < started:
+        raise ValueError("completed_at precedes started_at")
+    if completed.timestamp() > now.timestamp() + 300:
+        raise ValueError("completed_at is implausibly in the future")
+
+    ollama = receipt.get("ollama")
+    if not isinstance(ollama, dict) or ollama.get("base_url_class") != "loopback-local":
+        raise ValueError("receipt is not bound to a loopback-local Ollama endpoint")
+    candidate = ollama.get("candidate")
+    baseline = ollama.get("baseline")
+    c_identity = _validate_model_identity(ollama.get("candidate_identity"), candidate, "candidate")
+    b_identity = _validate_model_identity(ollama.get("baseline_identity"), baseline, "baseline")
+    if c_identity == b_identity:
+        raise ValueError("candidate and baseline resolve to the same manifest")
+    stability = ollama.get("identity_stability")
+    if not isinstance(stability, dict) or stability.get("stable") is not True:
+        raise ValueError("model identity stability is not proven")
+    if not (
+        stability.get("candidate_before_sha256") == c_identity
+        and stability.get("candidate_after_sha256") == c_identity
+        and stability.get("baseline_before_sha256") == b_identity
+        and stability.get("baseline_after_sha256") == b_identity
+    ):
+        raise ValueError("model identity drift detected in receipt")
+
+    candidate_metrics = _validate_model_measurement(candidate, "candidate")
+    baseline_metrics = _validate_model_measurement(baseline, "baseline")
+    comparisons = receipt.get("comparisons")
+    if not isinstance(comparisons, dict):
+        raise ValueError("comparison metrics missing")
+    speed = _finite_number(
+        comparisons.get("candidate_vs_baseline_wall_speed_ratio"), "wall speed ratio", 0.000001
+    )
+    expected_speed = baseline_metrics["latency"] / candidate_metrics["latency"]
+    if abs(speed - expected_speed) > 0.0001:
+        raise ValueError("wall speed ratio is inconsistent with measured latency")
+    uplift = _finite_number(
+        comparisons.get("candidate_minus_baseline_exact_match_points"), "accuracy uplift", -100.0, 100.0
+    )
+    expected_uplift = candidate_metrics["accuracy"] - baseline_metrics["accuracy"]
+    if abs(uplift - expected_uplift) > 0.001:
+        raise ValueError("accuracy uplift is inconsistent with measured accuracy")
+
+    quant_reference = receipt.get("quant_reference")
+    if not isinstance(quant_reference, dict):
+        raise ValueError("quant reference section missing")
+    _validate_cpu_reference(quant_reference.get("pca_pipeline"), "pca_pipeline")
+    _validate_cpu_reference(quant_reference.get("tda_stress_pipeline"), "tda_stress_pipeline")
+    gpu_comparison = quant_reference.get("gpu_acceleration_comparison")
+    if not isinstance(gpu_comparison, str) or not gpu_comparison.startswith("UNAVAILABLE:"):
+        raise ValueError("GPU acceleration status is not an explicit structured refusal")
+
+    dsse = envelope.get("dsse")
+    if not isinstance(dsse, dict):
+        raise ValueError("DSSE status missing")
+    signatures = dsse.get("signatures")
+    if not isinstance(signatures, list):
+        raise ValueError("DSSE signatures must be a list")
+    embedded = dsse.get("payload")
+    if embedded is not None:
+        if dsse.get("payloadType") != _QUANT_RECEIPT_PAYLOAD_TYPE:
+            raise ValueError("DSSE payload type mismatch")
+        try:
+            decoded = _base64.b64decode(embedded, validate=True)
+        except Exception as exc:
+            raise ValueError("DSSE payload is not valid base64") from exc
+        expected = _json.dumps(receipt, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        if decoded != expected:
+            raise ValueError("DSSE payload does not match receipt")
+    if dsse.get("signed") is True:
+        if not signatures or embedded is None:
+            raise ValueError("DSSE claims signed without signatures and payload")
+        verdict = _verify_envelope(dsse)
+        if not isinstance(verdict, dict) or verdict.get("verified") is not True:
+            reason = verdict.get("reason") if isinstance(verdict, dict) else None
+            suffix = ": " + str(reason) if reason else ""
+            raise ValueError("DSSE signature verification failed" + suffix)
+        signature_state = "SIGNED_VERIFIED"
+    elif signatures:
+        raise ValueError("unsigned DSSE contains signatures")
+    else:
+        signature_state = "UNSIGNED_CONTENT_ADDRESSED"
+
+    raw_fresh_seconds = _os.environ.get("SZL_QUANT_BENCH_FRESH_SECONDS", "604800")
+    try:
+        fresh_seconds = int(raw_fresh_seconds)
+    except ValueError as exc:
+        raise ValueError("SZL_QUANT_BENCH_FRESH_SECONDS must be an integer") from exc
+    if not 60 <= fresh_seconds <= 2_678_400:
+        raise ValueError("SZL_QUANT_BENCH_FRESH_SECONDS is outside the allowed range")
+    age_seconds = max(0, int((now - completed).total_seconds()))
+    return {
+        "envelope": envelope,
+        "age_seconds": age_seconds,
+        "freshness_state": "CURRENT" if age_seconds <= fresh_seconds else "HISTORICAL",
+        "candidate_manifest_sha256": c_identity,
+        "baseline_manifest_sha256": b_identity,
+        "signature_state": signature_state,
+    }
+
+
 def verify_claims_panel() -> dict:
-    """Resolve external reports against persisted, verified benchmark receipts.
+    """Read a bounded local benchmark receipt without producing side effects.
 
-    This GET path never signs, writes, benchmarks, or promotes reachability. With the
-    default empty receipt registry every SZL value remains null/ROADMAP.
+    Missing, semantically inconsistent, stale-looking, or tampered data never
+    becomes a live claim. Valid old receipts remain visible as HISTORICAL.
     """
-    reachable = _gpu_reachable()
-    rows = _resolved_quant_claims()
-    registry_basis = {
-        "status": DOCTRINE["registry_status"],
-        "digest": DOCTRINE["registry_digest"],
-        "signature": DOCTRINE["registry_signature"],
-        "locked_count": DOCTRINE["locked_count"],
-        "locked_ids": list(DOCTRINE["locked_proven"]),
-        "source": "formula_registry/formula-registry.v1.json",
-        "coverage": "non-exhaustive maturity crosswalk; not an inventory of every theorem",
-    }
+    configured_path = _os.environ.get("SZL_QUANT_BENCH_RECEIPT", "").strip()
+    receipt_candidates = ([_Path(configured_path)] if configured_path else [
+        _Path.home() / ".a11oy" / "receipts" / "quant-live-benchmark.json",
+        _Path(__file__).resolve().parent / "benchmarks" / "quant_live" / "receipts" / "latest.json",
+    ])
+    receipt_path = next((path for path in receipt_candidates if path.is_file()), receipt_candidates[0])
+    measured = None
+    validation = None
+    receipt_error = None
+    try:
+        if receipt_path.is_file() and receipt_path.stat().st_size <= 2_000_000:
+            envelope = _json.loads(receipt_path.read_text(encoding="utf-8"))
+            validation = _validate_quant_receipt(envelope)
+            measured = validation["envelope"]
+        else:
+            receipt_error = "measurement receipt absent"
+    except (OSError, ValueError, TypeError, _json.JSONDecodeError) as exc:
+        receipt_error = "%s: %s" % (type(exc).__name__, exc)
+
+    local = measured.get("receipt") if measured else {}
+    ollama = local.get("ollama", {})
+    candidate = ollama.get("candidate", {})
+    baseline = ollama.get("baseline", {})
+    comparisons = local.get("comparisons", {})
+    quant_reference = local.get("quant_reference", {})
+    freshness = (validation or {}).get("freshness_state", "NO_RECEIPT")
+    signature_state = (validation or {}).get("signature_state", "NO_RECEIPT")
+    signed = signature_state == "SIGNED_VERIFIED"
+
+    def cell(value, how):
+        if measured is None:
+            return {"szl_measured": None, "szl_label": "NOT_MEASURED", "how": how,
+                    "comparison_status": "NO_RECEIPT", "freshness_label": freshness}
+        return {"szl_measured": value, "szl_label": "MEASURED", "how": how,
+                "comparison_status": "BOUNDED_LOCAL_NOT_VENDOR_REPLICATION",
+                "freshness_label": freshness}
+
+    def no_gpu_claim(local_reference, how):
+        return {
+            "szl_measured": None,
+            "szl_label": "NOT_MEASURED",
+            "local_reference": local_reference if measured else None,
+            "local_reference_label": "MEASURED" if measured else "NOT_MEASURED",
+            "how": how,
+            "comparison_status": "NO_GPU_COMPARISON_RECEIPT" if measured else "NO_RECEIPT",
+            "freshness_label": freshness,
+        }
+
+    def vendor_row(claim, reported, values):
+        return {"claim": claim, "nvidia_datasheet": reported, "nvidia_label": "REPORTED", **values}
+
+    c_acc = candidate.get("exact_match", {})
+    c_ret = candidate.get("bounded_retrieval", {})
+    speed = comparisons.get("candidate_vs_baseline_wall_speed_ratio")
+    uplift = comparisons.get("candidate_minus_baseline_exact_match_points")
+    pca = quant_reference.get("pca_pipeline", {})
+    tda = quant_reference.get("tda_stress_pipeline", {})
+    rows = [
+        vendor_row("Nemotron speedup vs prior frontier", "up to 5x", no_gpu_claim(
+            ("%sx local Ollama wall-speed ratio vs %s" % (speed, baseline.get("model"))) if speed is not None else None,
+            "Local Ollama p50 wall latency is separate evidence; no vendor-frontier or GPU comparison receipt exists.")),
+        vendor_row("Reasoning/accuracy uplift", "+30%", cell(
+            ("%s percentage points vs local baseline" % uplift) if uplift is not None else None,
+            "Six preregistered deterministic exact-match operational probes; not a general reasoning benchmark.")),
+        vendor_row("Benchmark accuracy", "91%", cell(
+            ("%s%% (%s/%s exact match)" % (c_acc.get("accuracy_pct"), c_acc.get("tasks_passed"), c_acc.get("tasks_total"))) if c_acc else None,
+            "Bounded SZL exact-match operational suite; not NVIDIA's benchmark.")),
+        vendor_row("Long-context retrieval", "1M-token retrieval", cell(
+            ("%s/%s needles; max %s evaluated prompt tokens" % (c_ret.get("probes_passed"), c_ret.get("probes_total"), c_ret.get("max_prompt_eval_tokens"))) if c_ret else None,
+            "Bounded local needle probes; no one-million-token claim.")),
+        vendor_row("cuML PCA speedup (quant Layer 1)", "10-50x (S&P 500 scale); about 100x genomic", no_gpu_claim(
+            ("CPU reference p50 %s ms; GPU comparison UNAVAILABLE" % pca.get("p50_ms")) if pca else None,
+            "Measured CPU reference only; no distinct cuML execution receipt exists.")),
+        vendor_row("Ripser++ persistence (quant Layer 2)", "up to 30x vs CPU Ripser", no_gpu_claim(
+            ("CPU stress reference p50 %s ms; GPU comparison UNAVAILABLE" % tda.get("p50_ms")) if tda else None,
+            "Measured CPU reference only; no distinct Ripser++ execution receipt exists.")),
+    ]
+    for row in rows:
+        row.setdefault("local_reference", None)
+        row.setdefault("local_reference_label", "NOT_MEASURED")
     return {
         "service": "verify-the-claims",
         "doctrine": DOCTRINE["version"],
-        "schema_version": "szl.quant.claim-panel/v1",
-        "summary": ("ROADMAP until a preregistered experiment writes a digest-addressed, "
-                    "approved DSSE benchmark receipt that passes every promotion obligation."),
-        "gpu_reachable": reachable,
+        "summary": (("Current" if freshness == "CURRENT" else "Historical")
+                    + " bounded %s receipt loaded; vendor-scale and GPU comparisons remain out of scope."
+                    % ("cryptographically verified DSSE" if signed else "unsigned content-addressed")
+                    if measured else "No valid local measurement receipt is available; no number is invented."),
+        "gpu_reachable": _gpu_reachable(),
         "rows": rows,
-        "formula_registry": registry_basis,
-        "honesty": ("External reports are narrowly scoped and cited, not endorsed. SZL-MEASURED stays "
-                    "null/ROADMAP unless an immutable receipt passes schema, digest, signature, key-id, "
-                    "protocol, hardware, correctness, review, and freshness checks. GET never signs."),
+        "receipt": {"path_class": "operator-local", "loaded": bool(measured), "error": receipt_error,
+                    "content_sha256": local.get("content_sha256"), "completed_at": local.get("completed_at"),
+                    "dsse_signed": signed,
+                    "signature_state": signature_state,
+                    "freshness_state": freshness, "age_seconds": (validation or {}).get("age_seconds"),
+                    "candidate_manifest_sha256": (validation or {}).get("candidate_manifest_sha256"),
+                    "baseline_manifest_sha256": (validation or {}).get("baseline_manifest_sha256")},
+        "honesty": ("The NVIDIA column is a cited vendor claim, not an endorsement. The SZL column comes from a "
+                    "bounded local execution receipt and is not presented as a vendor-scale replication. Signature "
+                    "state is derived from cryptographic verification; unsigned content-addressed evidence is never "
+                    "displayed as signed."),
         "citations": [CITATIONS["rapids_cuml"], CITATIONS["ripserpp"]],
         "computed_at": _now_iso(),
     }
@@ -918,10 +1256,23 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
                + row("de-risk ratio", fmt(l3["derisk_ratio_vs_uninflated"]))
                + row("γ, κ", "%s, %s <small>(uncalibrated)</small>" % (l3["gamma"], l3["kappa"])))
     dsse = pipe["signed_receipt"]["dsse"]
-    signed = dsse.get("signed", False)
+    pipeline_signature_state = _dsse_signature_state(dsse)
+    pipeline_signed = pipeline_signature_state == "SIGNED_VERIFIED"
+    pipeline_receipt_title = (
+        "Verified Signed SAMPLE Receipt" if pipeline_signed else
+        "Unsigned SAMPLE Receipt" if pipeline_signature_state == "UNSIGNED_CONTENT_ADDRESSED" else
+        "Invalid DSSE SAMPLE Receipt"
+    )
+    pipeline_receipt_note = (
+        "DSSE signature verified against the configured SZL public key."
+        if pipeline_signed else
+        "Content-addressed DSSE envelope; no verified signature is present."
+        if pipeline_signature_state == "UNSIGNED_CONTENT_ADDRESSED" else
+        "DSSE signature is invalid or unverifiable; this receipt is not presented as signed."
+    )
     rc_body = (row("data source", "SAMPLE_SYNTHETIC")
                + row("pipeline", "<code>szl-gpu-quant-v0.1</code>")
-               + row("DSSE signed", fmt(signed))
+               + row("signature state", pipeline_signature_state)
                + row("PAE sha256", "<code>%s…</code>" % str(dsse.get("_pae_sha256", ""))[:16])
                + row("label", "<small>%s</small>" % SAMPLE_LABEL))
 
@@ -937,39 +1288,29 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
                 + gpus)
         tier_cards += card(t["tier"], t["label"], body, t.get("fits", ""))
 
-    def esc(value):
-        return _html_lib.escape(str(value), quote=True)
-
-    def measured_text(value):
-        if value is None:
-            return "—"
-        return "%s %s (%s)" % (value["value"], value["unit"], value["estimator"])
-
     vrows = ""
     for r in verify["rows"]:
-        report = r["external_report"]
-        source = report["source"]
-        blocked = "; ".join(r["blocked_by"])
-        external = ('<strong>%s</strong> %s<br><a href="%s" rel="noopener noreferrer">%s — %s</a>'
-                    '<br><small>%s</small>' % (
-                        esc(report["value"]), esc(report["units"]), esc(source["url"]),
-                        esc(source["organization"]), esc(source["title"]), esc(report["scope"])))
-        measured = ('<span class="pill-slot" data-label="%s"></span> %s<br>'
-                    '<small>protocol=%s · blocked: %s</small>' % (
-                        esc(r["szl_label"]), esc(measured_text(r["szl_measured"])),
-                        esc(r["protocol"]["id"]), esc(blocked)))
-        vrows += '<tr><td>%s</td><td class="ds">%s</td><td class="ms">%s</td></tr>' % (
-            esc(r["claim"]), external, measured)
-    verify_tbl = ('<table class="vt"><thead><tr><th>Claim</th><th>Externally reported (not reproduced)</th>'
-                  '<th>SZL-MEASURED (signed)</th></tr></thead><tbody>%s</tbody></table>' % vrows)
+        vrows += ('<tr><td>%s</td><td class="ds"><span class="pill-slot" data-label="%s"></span> %s</td>'
+                  '<td class="ms"><span class="pill-slot" data-label="%s"></span> %s<br><small>%s</small></td>'
+                  '<td class="ms"><span class="pill-slot" data-label="%s"></span> %s</td></tr>' % (
+                      r["claim"], r["nvidia_label"], r["nvidia_datasheet"],
+                      r["szl_label"], fmt(r["szl_measured"]), r.get("freshness_label", "NO_RECEIPT"),
+                      r["local_reference_label"], fmt(r["local_reference"])))
+    verify_tbl = ('<table class="vt"><thead><tr><th>Claim</th><th>NVIDIA published</th>'
+                  '<th>SZL comparison</th><th>Separate local evidence</th></tr></thead>'
+                  '<tbody>%s</tbody></table>' % vrows)
+    receipt_view = verify.get("receipt", {})
+    receipt_line = ("loaded=%s · completed_at=%s · signature=%s · content_sha256=%s" % (
+        receipt_view.get("loaded"), receipt_view.get("completed_at") or "—",
+        receipt_view.get("signature_state") or "UNKNOWN",
+        (str(receipt_view.get("content_sha256") or "—")[:20] + "…")
+        if receipt_view.get("content_sha256") else "—"))
 
     cards = "".join([
         card("Layer 1 · PCA Risk (LW + MP)", l1["label"].split(" | ")[0].replace("_SIGNAL", ""), l1_body, l1["honest_note"]),
         card("Layer 2 · TDA Fracture (β0/β1)", "SAMPLE", l2_body, l2["honest_note"]),
         card("Layer 3 · HJB-Kelly Sizing", "MODELED", l3_body, l3["honest_note"]),
-        card("Signed SAMPLE Receipt", "SAMPLE", rc_body,
-             ("DSSE envelope over the canonical receipt — REAL ECDSA when the cosign key is in the "
-              "runtime, else an explicit UNSIGNED honesty marker (never a fabricated signature).")),
+        card(pipeline_receipt_title, "SAMPLE", rc_body, pipeline_receipt_note),
     ])
 
     return """<!doctype html>
@@ -1005,18 +1346,18 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
 <header>
   <h1>Sovereign Quant Engine</h1>
   <p class="summary">__SUMMARY__</p>
-  <p class="sub">Three orthogonal risk signals per bar — PCA-Risk · TDA-Fracture · HJB-Kelly — each a SIGNED receipt, honestly labeled <b>SAMPLE_SIGNAL · NOT_LIVE · NO_BACKTEST_VALIDATED</b>. Not a trading instruction.</p>
+  <p class="sub">Three orthogonal risk signals per bar — PCA-Risk · TDA-Fracture · HJB-Kelly — with receipt state <b>__PIPE_SIG__</b>, honestly labeled <b>SAMPLE_SIGNAL · NOT_LIVE · NO_BACKTEST_VALIDATED</b>. Not a trading instruction.</p>
   <p class="state">backend=__BACKEND__ · gpu_reachable=__REACH__ · scenario=__SCEN__</p>
 </header>
-<h2>3-Layer Pipeline (signed SAMPLE receipt)</h2>
+<h2>3-Layer Pipeline (DSSE receipt: __PIPE_SIG__)</h2>
 <section class="grid">__CARDS__</section>
 <h2>2-GPU Sovereign Serve · Throttle Both</h2>
 <section class="grid">__TIERS__</section>
-<h2>Verify the Claims — externally reported vs SZL-MEASURED (signed)</h2>
-<section>__VERIFY__<p class="note">__VNOTE__</p></section>
+<h2>Verify the Claims — vendor statement vs bounded local receipt</h2>
+<section>__VERIFY__<p class="state">__VRECEIPT__</p><p class="note">__VNOTE__</p></section>
 <footer>
-  <p class="lock">Doctrine __DV__ LOCKED · locked-proven=__LC__ {__LP__} · __CORPUS__ @ __KC__ · registry=__RD__ (__RS__) · Λ = Conjecture 1 (NOT a theorem) · __SLSA__</p>
-  <p>SAMPLE = honest synthetic fixture (not live) · MODELED = labeled model output (uncalibrated) · ROADMAP = wiring ready, not measured yet (never faked). Primary sources: Ledoit-Wolf · Laloux/Bouchaud/Potters · Gidea-Katz arXiv:1703.04385 · RAPIDS/cuML docs · Ripser++ arXiv:2003.07989 · NVIDIA Nemotron 3 Ultra research.</p>
+  <p class="lock">Doctrine __DV__ LOCKED · locked-proven=__LC__ {__LP__} · __CORPUS__ @ __KC__ · Λ = Conjecture 1 (NOT a theorem) · __SLSA__</p>
+  <p>SAMPLE = honest synthetic fixture (not live) · MODELED = labeled model output (uncalibrated) · ROADMAP = wiring ready, not measured yet (never faked). Cites: Brodetsky (LinkedIn) · Ledoit-Wolf (honey.pdf) · Laloux/Bouchaud/Potters · Gidea-Katz arXiv:1703.04385 · RAPIDS/cuML · giotto-tda · Ripser++ arXiv:2003.07989.</p>
 </footer>
 <script src="/static/shared/szl_label_engine.js"></script>
 <script>
@@ -1029,7 +1370,8 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
         title: (label === "SAMPLE") ? "Honest synthetic fixture — not a live feed, no backtest." :
                (label === "MODELED") ? "Labeled model output — uncalibrated, not measured." :
                (label === "LIVE") ? "Real backend wired and live." :
-               "Wiring ready; not measured yet. ROADMAP, never faked."});
+               (label === "NOT_MEASURED") ? "No valid execution receipt is loaded; no value is invented." :
+               "Capability state reported by the live surface."});
     }
     return '<span>' + label + '</span>';
   }
@@ -1039,21 +1381,21 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
 })();
 </script>
 </body></html>""" \
-        .replace("__SUMMARY__", "VRAM-resident quant pipeline (honest CPU fallback today; GPU path ROADMAP)") \
+        .replace("__SUMMARY__", "Operational bounded quant pipeline; CPU reference measured, GPU comparison requires a kernel receipt") \
         .replace("__BACKEND__", str(backend["backend"])) \
         .replace("__REACH__", str(backend["gpu_reachable"])) \
         .replace("__SCEN__", str(pipe["scenario"])) \
+        .replace("__PIPE_SIG__", pipeline_signature_state) \
         .replace("__CARDS__", cards) \
         .replace("__TIERS__", tier_cards) \
         .replace("__VERIFY__", verify_tbl) \
+        .replace("__VRECEIPT__", receipt_line) \
         .replace("__VNOTE__", verify["honesty"]) \
         .replace("__DV__", d["version"]) \
         .replace("__LC__", str(d["locked_count"])) \
         .replace("__LP__", ", ".join(d["locked_proven"])) \
         .replace("__CORPUS__", d["corpus"]) \
         .replace("__KC__", d["kernel_commit"]) \
-        .replace("__RD__", str(d.get("registry_digest") or "UNAVAILABLE")) \
-        .replace("__RS__", str(d.get("registry_status") or "UNAVAILABLE")) \
         .replace("__SLSA__", d["slsa"])
 
 
@@ -1147,10 +1489,11 @@ def _selftest() -> dict:
         assert t["sovereign"] == tp["gpu_reachable"], t
     out["tiers_sovereign_honest"] = True
 
-    # (f) Verify-claims: SZL-MEASURED column is empty/ROADMAP (never the datasheet number).
+    # (f) Verify-claims: without a receipt no measured number is invented.
     vc = verify_claims_panel()
-    assert all(r["szl_measured"] is None and r["szl_label"] == "ROADMAP" for r in vc["rows"]), vc
-    out["verify_claims_roadmap"] = True
+    if not vc["receipt"]["loaded"]:
+        assert all(r["szl_measured"] is None and r["szl_label"] == "NOT_MEASURED" for r in vc["rows"]), vc
+    out["verify_claims_receipt_gate"] = True
 
     # (g) HTML renders, non-trivial, no forbidden raw claims.
     h = _html(pipe, tp, vc)

szl_involution_probe.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Stephen P. Lutar Jr. / SZL Holdings
+"""Pure, bounded decomposition of paired observations under an involution.
+
+Taxonomy home: provenance / EvidenceOS analysis.
+
+This module is a clean-room systems adaptation of a general symmetry idea used in
+the cited transport study.  It copies no article prose, figure, or implementation.
+The caller declares a permutation ``P`` and supplies a left observation ``x`` and
+an observation ``y`` collected on the transformed surface.  With the convention
+``(P v)[i] = v[P[i]]`` and a required involution ``P(P(i)) = i``, the probe aligns
+the transformed observation and computes::
+
+    y_aligned = P^-1 y
+    S = (x + y_aligned) / 2
+    A = (x - y_aligned) / 2
+
+The algebraic reconstruction identities are labelled PROVEN.  A concrete result
+is MODELED because it is derived from caller-supplied observations, not measured
+by this module.  The motivating experimental findings remain REPORTED.
+
+Primary-source citations:
+  * https://doi.org/10.1038/s41467-026-75369-y
+  * https://doi.org/10.5281/zenodo.17050703
+
+The probe is deliberately pure: it performs no file or network I/O, emits no
+signature, writes no receipt, and invokes no effector.
+"""
+
+import hashlib
+import json
+import math
+import numbers
+from collections.abc import Sequence
+
+
+SCHEMA = "szl.evidenceos.involution-probe.v1"
+MAX_DIMENSION = 4096
+MAX_ABS_VALUE = 1.0e12
+MAX_PAIR_ID_BYTES = 256
+
+LABEL_PROVEN = "PROVEN"
+LABEL_MODELED = "MODELED"
+LABEL_REPORTED = "REPORTED"
+
+VERDICT_DECOMPOSED = "DECOMPOSED"
+VERDICT_REFUSED = "REFUSED"
+
+ARTICLE_DOI = "10.1038/s41467-026-75369-y"
+DATA_CODE_DOI = "10.5281/zenodo.17050703"
+
+_CITATIONS = (
+    {
+        "kind": "article",
+        "doi": ARTICLE_DOI,
+        "url": "https://doi.org/" + ARTICLE_DOI,
+        "evidence_label": LABEL_REPORTED,
+    },
+    {
+        "kind": "data-and-code",
+        "doi": DATA_CODE_DOI,
+        "url": "https://doi.org/" + DATA_CODE_DOI,
+        "evidence_label": LABEL_REPORTED,
+    },
+)
+
+
+class _Refusal(ValueError):
+    """Internal, bounded validation refusal converted to a public result."""
+
+    def __init__(self, code: str, reason: str):
+        super().__init__(reason)
+        self.code = code
+        self.reason = reason
+
+
+def _canonical_for_digest(value):
+    """Return a JSON-safe projection with platform-stable finite-float encoding."""
+    if isinstance(value, float):
+        # Validation guarantees finiteness.  Normalizing negative zero prevents two
+        # numerically identical decompositions from receiving different digests.
+        normalized = 0.0 if value == 0.0 else value
+        return {"float_hex": normalized.hex()}
+    if isinstance(value, dict):
+        return {str(key): _canonical_for_digest(item)
+                for key, item in sorted(value.items(), key=lambda pair: str(pair[0]))}
+    if isinstance(value, (list, tuple)):
+        return [_canonical_for_digest(item) for item in value]
+    return value
+
+
+def _stable_digest(payload: dict) -> str:
+    canonical = json.dumps(
+        _canonical_for_digest(payload),
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    )
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def _utf8_size(value: str) -> int:
+    try:
+        return len(value.encode("utf-8"))
+    except UnicodeEncodeError as exc:
+        raise _Refusal("PAIR_ID_INVALID", "pair_id must be valid UTF-8 text") from exc
+
+
+def _validate_pair_id(pair_id) -> str:
+    if not isinstance(pair_id, str) or not pair_id.strip():
+        raise _Refusal("PAIR_ID_REQUIRED", "pair_id must be a non-blank string")
+    if _utf8_size(pair_id) > MAX_PAIR_ID_BYTES:
+        raise _Refusal("PAIR_ID_TOO_LARGE", "pair_id exceeds the byte bound")
+    return pair_id
+
+
+def _as_bounded_vector(name: str, value) -> tuple[float, ...]:
+    if value is None:
+        raise _Refusal("PAIR_MISSING", f"{name} is required")
+    if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
+        raise _Refusal("VECTOR_INVALID", f"{name} must be a finite numeric sequence")
+    size = len(value)
+    if size < 1 or size > MAX_DIMENSION:
+        raise _Refusal("DIMENSION_OUT_OF_BOUNDS", f"{name} dimension is outside bounds")
+
+    out: list[float] = []
+    for item in value:
+        if isinstance(item, bool) or not isinstance(item, numbers.Real):
+            raise _Refusal("VECTOR_INVALID", f"{name} contains a non-real value")
+        number = float(item)
+        if not math.isfinite(number):
+            raise _Refusal("VECTOR_NONFINITE", f"{name} contains a non-finite value")
+        if abs(number) > MAX_ABS_VALUE:
+            raise _Refusal("VALUE_OUT_OF_BOUNDS", f"{name} exceeds the magnitude bound")
+        out.append(0.0 if number == 0.0 else number)
+    return tuple(out)
+
+
+def _as_involution(permutation, dimension: int) -> tuple[int, ...]:
+    if permutation is None:
+        raise _Refusal("PERMUTATION_REQUIRED", "a declared permutation is required")
+    if (isinstance(permutation, (str, bytes, bytearray))
+            or not isinstance(permutation, Sequence)):
+        raise _Refusal("PERMUTATION_INVALID", "permutation must be an integer sequence")
+    if len(permutation) != dimension:
+        raise _Refusal("DIMENSION_MISMATCH", "permutation and vectors must share a dimension")
+    if any(isinstance(index, bool) or not isinstance(index, int)
+           for index in permutation):
+        raise _Refusal("PERMUTATION_INVALID", "permutation indices must be integers")
+
+    result = tuple(permutation)
+    if any(index < 0 or index >= dimension for index in result):
+        raise _Refusal("PERMUTATION_OUT_OF_RANGE", "permutation index is outside the vector")
+    if len(set(result)) != dimension:
+        raise _Refusal("PERMUTATION_NOT_BIJECTIVE", "permutation must be bijective")
+    if any(result[result[index]] != index for index in range(dimension)):
+        raise _Refusal("PERMUTATION_NOT_INVOLUTION", "declared permutation does not satisfy P^2=I")
+    return result
+
+
+def _apply_permutation(vector: tuple[float, ...], permutation: tuple[int, ...]) -> tuple[float, ...]:
+    return tuple(vector[index] for index in permutation)
+
+
+def _linf(values) -> float:
+    return max((abs(value) for value in values), default=0.0)
+
+
+def _labels() -> dict:
+    return {
+        "algebraic_contract": LABEL_PROVEN,
+        "computed_observation": LABEL_MODELED,
+        "external_findings": LABEL_REPORTED,
+        "note": (
+            "PROVEN is limited to the finite-vector identities checked here; "
+            "MODELED is a deterministic transform of caller-supplied observations; "
+            "REPORTED identifies claims made by the cited primary sources."
+        ),
+        "adds_to_locked_8": 0,
+    }
+
+
+def _refusal(pair_id, code: str, reason: str) -> dict:
+    safe_pair_id = None
+    if isinstance(pair_id, str):
+        try:
+            if _utf8_size(pair_id) <= MAX_PAIR_ID_BYTES:
+                safe_pair_id = pair_id
+        except _Refusal:
+            pass
+    core = {
+        "schema": SCHEMA,
+        "ok": False,
+        "verdict": VERDICT_REFUSED,
+        "pair_id": safe_pair_id,
+        "refusal": {"code": code, "reason": reason},
+        "labels": _labels(),
+        "citations": [dict(citation) for citation in _CITATIONS],
+    }
+    core["digest"] = {
+        "algorithm": "sha256",
+        "stable_content_sha256": _stable_digest(core),
+        "signed": False,
+    }
+    return core
+
+
+def evaluate_involution_pair(*, pair_id, left_observation, transformed_observation,
+                             permutation) -> dict:
+    """Validate and decompose one declared involution pair.
+
+    Returns a deterministic ``DECOMPOSED`` result or a deterministic ``REFUSED``
+    result for an incomplete, unbounded, non-finite, mismatched, non-bijective, or
+    non-involutive input.  Programmer faults are not hidden by a broad exception.
+    """
+    try:
+        validated_pair_id = _validate_pair_id(pair_id)
+        left = _as_bounded_vector("left_observation", left_observation)
+        transformed = _as_bounded_vector("transformed_observation", transformed_observation)
+        if len(left) != len(transformed):
+            raise _Refusal("PAIR_DIMENSION_MISMATCH", "paired vectors must share a dimension")
+        involution = _as_involution(permutation, len(left))
+    except _Refusal as refusal:
+        return _refusal(pair_id, refusal.code, refusal.reason)
+
+    # P^-1 is P because validation established P^2=I.
+    aligned = _apply_permutation(transformed, involution)
+    symmetric = tuple((a + b) / 2.0 for a, b in zip(left, aligned))
+    antisymmetric = tuple((a - b) / 2.0 for a, b in zip(left, aligned))
+
+    reconstructed_left = tuple(s + a for s, a in zip(symmetric, antisymmetric))
+    reconstructed_aligned = tuple(s - a for s, a in zip(symmetric, antisymmetric))
+    reconstructed_transformed = _apply_permutation(reconstructed_aligned, involution)
+
+    permutation_closure_residual = max(
+        (abs(involution[involution[index]] - index) for index in range(len(involution))),
+        default=0,
+    )
+    reconstruction_residual = _linf(
+        [actual - reconstructed for actual, reconstructed in zip(left, reconstructed_left)]
+        + [actual - reconstructed
+           for actual, reconstructed in zip(transformed, reconstructed_transformed)]
+    )
+    paired_delta = _linf(a - b for a, b in zip(left, aligned))
+
+    input_contract = {
+        "pair_id": validated_pair_id,
+        "dimension": len(left),
+        "permutation": list(involution),
+        "left_observation": list(left),
+        "transformed_observation": list(transformed),
+        "permutation_convention": "(P v)[i] = v[P[i]]",
+    }
+    result_core = {
+        "schema": SCHEMA,
+        "ok": True,
+        "verdict": VERDICT_DECOMPOSED,
+        "pair_id": validated_pair_id,
+        "bounds": {
+            "max_dimension": MAX_DIMENSION,
+            "max_abs_value": MAX_ABS_VALUE,
+            "max_pair_id_bytes": MAX_PAIR_ID_BYTES,
+        },
+        "contract": {
+            "permutation_convention": "(P v)[i] = v[P[i]]",
+            "requires_involution": True,
+            "aligned_transformed": "P^-1(transformed_observation)",
+            "symmetric": "(left + aligned_transformed) / 2",
+            "antisymmetric": "(left - aligned_transformed) / 2",
+        },
+        "input": {
+            "dimension": len(left),
+            "permutation": list(involution),
+        },
+        "decomposition": {
+            "aligned_transformed": list(aligned),
+            "symmetric": list(symmetric),
+            "antisymmetric": list(antisymmetric),
+        },
+        "closure": {
+            "permutation_squared_identity": permutation_closure_residual == 0,
+            "permutation_closure_residual": permutation_closure_residual,
+            "pair_reconstruction_residual_linf": reconstruction_residual,
+            "paired_delta_linf": paired_delta,
+        },
+        "labels": _labels(),
+        "citations": [dict(citation) for citation in _CITATIONS],
+        "effects": {
+            "writes": 0,
+            "signatures": 0,
+            "effectors": 0,
+            "network_calls": 0,
+        },
+    }
+    result_core["digests"] = {
+        "algorithm": "sha256",
+        "input_sha256": _stable_digest({"schema": SCHEMA, "input": input_contract}),
+        "result_sha256": _stable_digest(result_core),
+        "signed": False,
+    }
+    return result_core
+
+
+__all__ = [
+    "ARTICLE_DOI",
+    "DATA_CODE_DOI",
+    "LABEL_MODELED",
+    "LABEL_PROVEN",
+    "LABEL_REPORTED",
+    "MAX_ABS_VALUE",
+    "MAX_DIMENSION",
+    "MAX_PAIR_ID_BYTES",
+    "SCHEMA",
+    "VERDICT_DECOMPOSED",
+    "VERDICT_REFUSED",
+    "evaluate_involution_pair",
+]
+
+
+def register(app, ns="a11oy"):
+    """Register the read-only contract view and bounded evaluation endpoint."""
+    from fastapi import Request
+    from fastapi.responses import JSONResponse
+
+    base = "/api/%s/v1/evidenceos/involution" % ns
+
+    def _json_response(body, status_code=200):
+        response = JSONResponse(body, status_code=status_code)
+        response.headers["Cache-Control"] = "no-store"
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        return response
+
+    @app.get(base + "/info")
+    async def _involution_info():  # noqa: ANN202
+        return _json_response({
+            "schema": SCHEMA,
+            "service_state": "LIVE",
+            "effectors": 0,
+            "writes": 0,
+            "max_dimension": MAX_DIMENSION,
+            "permutation_contract": "(P v)[i] = v[P[i]] and P^2 = I",
+            "labels": _labels(),
+            "citations": [dict(citation) for citation in _CITATIONS],
+            "receipt_policy": "pure computation; content digest returned; no state write and no signature minted",
+        })
+
+    @app.post(base + "/evaluate")
+    async def _involution_evaluate(request: Request):  # noqa: ANN202
+        raw = await request.body()
+        if len(raw) > 200_000:
+            return _json_response({"ok": False, "verdict": VERDICT_REFUSED,
+                                   "refusal": {"code": "BODY_TOO_LARGE", "reason": "request exceeds 200000 bytes"}},
+                                  status_code=413)
+        try:
+            body = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            return _json_response({"ok": False, "verdict": VERDICT_REFUSED,
+                                   "refusal": {"code": "INVALID_JSON", "reason": "request body must be JSON"}},
+                                  status_code=400)
+        if not isinstance(body, dict):
+            return _json_response({"ok": False, "verdict": VERDICT_REFUSED,
+                                   "refusal": {"code": "INVALID_BODY", "reason": "request body must be an object"}},
+                                  status_code=400)
+        allowed = {"pair_id", "left_observation", "transformed_observation", "permutation"}
+        unknown = sorted(str(key) for key in body if key not in allowed)
+        if unknown:
+            return _json_response({"ok": False, "verdict": VERDICT_REFUSED,
+                                   "refusal": {"code": "UNKNOWN_FIELDS", "reason": "unexpected fields", "fields": unknown}},
+                                  status_code=400)
+        result = evaluate_involution_pair(
+            pair_id=body.get("pair_id"),
+            left_observation=body.get("left_observation"),
+            transformed_observation=body.get("transformed_observation"),
+            permutation=body.get("permutation"),
+        )
+        return _json_response(result, status_code=200 if result["ok"] else 422)
+
+    return {"ok": True, "routes": [base + "/info", base + "/evaluate"]}
+
+
+__all__.append("register")

szl_runtime_contracts.py

@@ -0,0 +1,421 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Stephen P. Lutar Jr. / SZL Holdings
+"""Bounded runtime contracts for the a11oy service layer.
+
+Taxonomy home: services/ (runtime health, identity, and observability posture).
+
+The four read-only endpoints deliberately answer different questions:
+
+* ``/api/livez`` proves only that this Python process can answer a request.
+* ``/api/readyz`` re-walks the configured Khipu chain and folds in the existing
+  boot-preflight signal.  Missing or non-durable chain state fails closed.
+* ``/api/build-info`` emits only observable, allowlisted build metadata.
+* ``/api/<ns>/v1/otel/status`` separates in-process propagation, exporter
+  configuration, and fresh collector delivery evidence.
+
+GETs never mint receipts, sign data, contact an upstream, or write to disk.
+"""
+
+import os
+import platform
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+
+_STARTED_MONOTONIC = time.monotonic()
+_SHA_RE = re.compile(r"(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})\Z")
+_VERSION_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._+\-]{0,63}\Z")
+_ENV_SHA_NAMES = (
+    "A11OY_GIT_SHA",
+    "GITHUB_SHA",
+    "VERCEL_GIT_COMMIT_SHA",
+    "SOURCE_VERSION",
+    "GIT_COMMIT",
+)
+_ENV_VERSION_NAMES = ("A11OY_VERSION", "APP_VERSION", "RELEASE_VERSION")
+_DURABLE_BACKENDS = {"sqlite", "json", "postgres", "postgresql", "lmdb"}
+_FRESH_COLLECTOR_EVIDENCE_S = 120.0
+
+
+def _no_store_json(content: dict[str, Any], status_code: int = 200):
+    from fastapi.responses import JSONResponse
+
+    response = JSONResponse(content=content, status_code=status_code)
+    response.headers["Cache-Control"] = "no-store"
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    return response
+
+
+def _safe_env_sha() -> tuple[Optional[str], Optional[str]]:
+    for name in _ENV_SHA_NAMES:
+        value = str(os.environ.get(name, "")).strip()
+        if _SHA_RE.fullmatch(value):
+            return value.lower(), f"env:{name}"
+    return None, None
+
+
+def _safe_git(args: list[str]) -> Optional[subprocess.CompletedProcess[str]]:
+    """Run one bounded, read-only git query; never uses a shell."""
+    try:
+        return subprocess.run(
+            ["git", *args],
+            cwd=Path(__file__).resolve().parent,
+            capture_output=True,
+            text=True,
+            timeout=0.75,
+            check=False,
+        )
+    except (FileNotFoundError, OSError, subprocess.SubprocessError):
+        return None
+
+
+def _build_identity() -> dict[str, Any]:
+    sha, source = _safe_env_sha()
+    if sha is None:
+        result = _safe_git(["rev-parse", "HEAD"])
+        candidate = result.stdout.strip() if result and result.returncode == 0 else ""
+        if _SHA_RE.fullmatch(candidate):
+            sha, source = candidate.lower(), "git:HEAD"
+
+    version = None
+    version_source = None
+    for name in _ENV_VERSION_NAMES:
+        candidate = str(os.environ.get(name, "")).strip()
+        if _VERSION_RE.fullmatch(candidate):
+            version, version_source = candidate, f"env:{name}"
+            break
+
+    dirty: Optional[bool] = None
+    status = _safe_git(["status", "--porcelain", "--untracked-files=normal"])
+    if status and status.returncode == 0:
+        dirty = bool(status.stdout.strip())
+
+    return {
+        "state": "OBSERVED" if sha else "UNKNOWN",
+        "revision": sha,
+        "revision_source": source or "UNKNOWN",
+        "version": version,
+        "version_source": version_source or "UNKNOWN",
+        "working_tree": (
+            "DIRTY" if dirty is True else "CLEAN" if dirty is False else "UNKNOWN"
+        ),
+    }
+
+
+def _verify_khipu_store(app: Any) -> dict[str, Any]:
+    state = getattr(app, "state", None)
+    store = getattr(state, "be_khipu", None) if state is not None else None
+    if store is not None and callable(getattr(store, "verify", None)):
+        backend = str(getattr(store, "backend", "UNKNOWN"))
+        try:
+            result = store.verify()
+            if not isinstance(result, tuple) or len(result) != 3:
+                raise ValueError("verify() returned an unsupported contract")
+            intact, depth, first_break = result
+            durable = backend.lower() in _DURABLE_BACKENDS
+            ready = bool(intact) and durable
+            return {
+                "state": "READY" if ready else "NOT_READY",
+                "source": "app.state.be_khipu",
+                "chain_intact": bool(intact),
+                "depth": int(depth),
+                "first_break_seq": int(first_break),
+                "backend": backend,
+                "durable": durable,
+                "blocking": not ready,
+            }
+        except Exception as exc:
+            return {
+                "state": "UNAVAILABLE",
+                "source": "app.state.be_khipu",
+                "backend": backend,
+                "durable": backend.lower() in _DURABLE_BACKENDS,
+                "blocking": True,
+                "error_type": type(exc).__name__,
+            }
+
+    # Some small deployments use the shared in-process DAG registry without
+    # szl_be_hardening.  Re-walk it for diagnostic evidence, but never promote
+    # an in-memory registry to readiness: intact links do not prove durable
+    # receipt persistence.
+    try:
+        import szl_khipu_verify
+
+        report = szl_khipu_verify.list_organs()
+        organs = list(report.get("organs") or [])
+        if not organs:
+            return {
+                "state": "UNKNOWN",
+                "source": "szl_khipu_verify.list_organs",
+                "organ_count": 0,
+                "blocking": True,
+                "reason": "no observed Khipu DAG in this process",
+            }
+        intact_values = [row.get("links_intact") for row in organs]
+        all_intact = all(value is True for value in intact_values)
+        return {
+            "state": "NOT_READY",
+            "source": "szl_khipu_verify.list_organs",
+            "organ_count": len(organs),
+            "chains_intact": all_intact,
+            "backend": "in-process-registry",
+            "durable": False,
+            "blocking": True,
+            "reason": (
+                "in-process DAG links are intact but durable persistence is not observed"
+                if all_intact
+                else "in-process DAG links are not intact and durable persistence is not observed"
+            ),
+        }
+    except Exception as exc:
+        return {
+            "state": "UNAVAILABLE",
+            "source": "szl_khipu_verify.list_organs",
+            "blocking": True,
+            "error_type": type(exc).__name__,
+        }
+
+
+def _boot_preflight() -> dict[str, Any]:
+    try:
+        import szl_boot_preflight
+
+        report = szl_boot_preflight.readiness()
+        overall = str(report.get("overall", "UNKNOWN")).upper()
+        # Missing optional cloud credentials are explicitly DEGRADED, not a
+        # failure of the local core.  A hard-required dependency is UNAVAILABLE.
+        blocking = overall not in {"LIVE", "DEGRADED"}
+        return {
+            "state": overall,
+            "source": "szl_boot_preflight.readiness",
+            "subsystem_count": len(report.get("subsystems") or []),
+            "blocking": blocking,
+        }
+    except Exception as exc:
+        return {
+            "state": "UNAVAILABLE",
+            "source": "szl_boot_preflight.readiness",
+            "blocking": True,
+            "error_type": type(exc).__name__,
+        }
+
+
+def _readiness(app: Any) -> tuple[dict[str, Any], int]:
+    components = {
+        "khipu": _verify_khipu_store(app),
+        "boot_preflight": _boot_preflight(),
+    }
+    blockers = [name for name, value in components.items() if value.get("blocking")]
+    ready = not blockers
+    body = {
+        "status": "READY" if ready else "NOT_READY",
+        "ready": ready,
+        "components": components,
+        "blocking_components": blockers,
+        "receipt_minted": False,
+    }
+    return body, 200 if ready else 503
+
+
+def _collector_evidence(app: Any, exporter_configured: bool) -> dict[str, Any]:
+    state = getattr(app, "state", None)
+    evidence = getattr(state, "otel_collector_evidence", None) if state is not None else None
+    if isinstance(evidence, dict):
+        try:
+            observed = float(evidence["observed_at_unix"])
+            age = max(0.0, time.time() - observed)
+            if age <= _FRESH_COLLECTOR_EVIDENCE_S and isinstance(
+                evidence.get("reachable"), bool
+            ):
+                reachable = bool(evidence["reachable"])
+                return {
+                    "state": "REACHABLE" if reachable else "UNREACHABLE",
+                    "evidence": "FRESH_PROBE",
+                    "age_s": round(age, 3),
+                }
+            return {
+                "state": "UNKNOWN",
+                "evidence": "STALE_OR_INVALID_PROBE",
+                "age_s": round(age, 3),
+            }
+        except (KeyError, TypeError, ValueError, OverflowError):
+            pass
+    return {
+        "state": "UNKNOWN" if exporter_configured else "UNAVAILABLE",
+        "evidence": "NO_FRESH_DELIVERY_PROBE",
+        "age_s": None,
+    }
+
+
+def _otel_posture(app: Any) -> dict[str, Any]:
+    installed = bool(getattr(app, "_vsp_otel_installed", False))
+    exporter_raw = str(getattr(app, "_vsp_otel_exporter", "UNAVAILABLE"))
+    policy = dict(getattr(app, "_vsp_otel_endpoint_policy", {}) or {})
+
+    # Prefer the existing VSP status object when it is available, but recompute
+    # maturity below: VSP propagation is not proof of collector delivery.
+    try:
+        import vsp_otel.middleware as vsp_otel
+
+        existing = vsp_otel.status(app)
+        installed = existing.get("propagation") == "READY"
+        exporter_raw = str(existing.get("exporter", exporter_raw))
+        endpoint = existing.get("endpoint")
+        if isinstance(endpoint, dict):
+            policy = endpoint
+    except Exception:
+        pass
+
+    exporter_configured = exporter_raw.startswith("otlp-grpc:configured:")
+    collector = _collector_evidence(app, exporter_configured)
+    if collector["state"] == "REACHABLE":
+        overall = "LIVE"
+    elif installed:
+        overall = "DEGRADED"
+    else:
+        overall = "UNAVAILABLE"
+    return {
+        "status": overall,
+        "in_process": {
+            "state": "LIVE" if installed else "UNAVAILABLE",
+            "trace_propagation": "READY" if installed else "UNAVAILABLE",
+        },
+        "exporter": {
+            "state": "CONFIGURED_UNVERIFIED" if exporter_configured else "UNAVAILABLE",
+            "endpoint_policy": str(policy.get("state", "UNKNOWN")),
+            "endpoint_fingerprint": policy.get("fingerprint"),
+            "delivery_asserted": False,
+        },
+        "collector": collector,
+        "receipt_minted": False,
+        "note": "in-process trace propagation is separate from exporter configuration and collector delivery",
+    }
+
+
+def _looks_like_file_or_well_known(path: str) -> bool:
+    if path == "/.well-known" or path.startswith("/.well-known/"):
+        return True
+    last = path.rsplit("/", 1)[-1]
+    return bool(last and "." in last and last not in {".", ".."})
+
+
+def _matched_by_path_catchall(app: Any, scope: dict[str, Any]) -> bool:
+    """Return True only when the first matching route is a ``:path`` wildcard."""
+    try:
+        from starlette.routing import Match
+
+        for route in app.router.routes:
+            matches = getattr(route, "matches", None)
+            if not callable(matches):
+                continue
+            match, _ = matches(scope)
+            if match == Match.FULL:
+                template = str(getattr(route, "path", ""))
+                return ":path}" in template
+    except Exception:
+        return False
+    return False
+
+
+def _install_soft_404_guard(app: Any) -> None:
+    if getattr(app.state, "szl_runtime_soft_404_guard", False):
+        return
+
+    @app.middleware("http")
+    async def _runtime_soft_404_guard(request, call_next):
+        suspicious = request.method in {"GET", "HEAD"} and _looks_like_file_or_well_known(
+            request.url.path
+        )
+        catchall_match = suspicious and _matched_by_path_catchall(app, request.scope)
+        response = await call_next(request)
+        content_type = str(response.headers.get("content-type", "")).lower()
+        if catchall_match and response.status_code == 200 and "text/html" in content_type:
+            return _no_store_json(
+                {
+                    "status": "NOT_FOUND",
+                    "path": request.url.path,
+                    "reason": "unknown file-like path refused SPA fallback",
+                },
+                status_code=404,
+            )
+        return response
+
+    app.state.szl_runtime_soft_404_guard = True
+
+
+def _front_move_new_routes(app: Any, previous_ids: set[int]) -> None:
+    """Ensure exact contracts win even when register() follows a SPA catch-all."""
+    added = [route for route in app.router.routes if id(route) not in previous_ids]
+    if not added:
+        return
+    old = [route for route in app.router.routes if id(route) in previous_ids]
+    app.router.routes[:] = added + old
+
+
+def register(app: Any, ns: str = "a11oy") -> dict[str, Any]:
+    """Register idempotent, read-only runtime endpoints and the soft-404 guard."""
+    if getattr(app.state, "szl_runtime_contracts_registered", False):
+        return {"registered": False, "reason": "already_registered"}
+
+    previous_ids = {id(route) for route in app.router.routes}
+    # Git inspection is a bounded startup observation, not request work.  Keep
+    # the immutable snapshot in this registration closure so public GETs never
+    # spawn child processes or re-read the working tree.
+    build_identity = _build_identity()
+
+    @app.get("/api/livez", tags=["runtime"], include_in_schema=True)
+    async def _livez():
+        return _no_store_json(
+            {
+                "status": "LIVE",
+                "process": {
+                    "pid": os.getpid(),
+                    "uptime_s": round(time.monotonic() - _STARTED_MONOTONIC, 3),
+                    "python_implementation": platform.python_implementation(),
+                },
+                "scope": "process liveness only; no dependency readiness asserted",
+                "receipt_minted": False,
+            }
+        )
+
+    @app.get("/api/readyz", tags=["runtime"], include_in_schema=True)
+    async def _readyz():
+        body, status = _readiness(app)
+        return _no_store_json(body, status_code=status)
+
+    @app.get("/api/build-info", tags=["runtime"], include_in_schema=True)
+    async def _build_info():
+        return _no_store_json(
+            {
+                "status": "OBSERVED",
+                "service": ns,
+                "build": build_identity,
+                "runtime": {
+                    "python": platform.python_version(),
+                    "platform": sys.platform,
+                },
+                "receipt_minted": False,
+            }
+        )
+
+    @app.get(f"/api/{ns}/v1/otel/status", tags=["runtime"], include_in_schema=True)
+    async def _otel_status():
+        return _no_store_json(_otel_posture(app))
+
+    _front_move_new_routes(app, previous_ids)
+    _install_soft_404_guard(app)
+    app.state.szl_runtime_contracts_registered = True
+    return {
+        "registered": True,
+        "routes": [
+            "/api/livez",
+            "/api/readyz",
+            "/api/build-info",
+            f"/api/{ns}/v1/otel/status",
+        ],
+        "external_writes": False,
+    }