deploy(hf): sync szl-holdings/a11oy@main derived COPY set

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy main.
Files: 1126 Pruned: 0
Derived from Dockerfile COPY sources (NO hand-maintained allowlist).

Signed-off-by: SZL Holdings <noreply@szlholdings.ai>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

a11oy_frontier_page.py

@@ -20,8 +20,7 @@ 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 composite inference-provenance capability (UNAVAILABLE until a real write
-    has minted an independently visible artifact).
+  - the ROADMAP composite inference-provenance-receipt play (clearly labeled).
 
 HONESTY (doctrine v11, non-negotiable):
   * A persistent honest banner is pinned to the top of every viewport and a
@@ -688,7 +687,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 — source, dependency, or required artifact is not operationally evidenced.</div>`;
+    banner = `<div class="tile-banner unavailable">UNAVAILABLE — sub-source down right now; reported honestly, not faked.</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>
@@ -793,11 +792,6 @@ 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 = [
@@ -805,22 +799,18 @@ 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">source reachability <b>${{esc(source.state || 'UNKNOWN')}}</b></span>`,
-      `<span class="chip">operational readiness <b>${{esc(readiness.state || 'UNKNOWN')}}</b></span>`,
+      `<span class="chip">all sources live: <b>${{esc(String(s.all_sources_live))}}</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 = 'manifest reachable · composed from ' + esc(MANIFEST_EP) +
-      ' · ' + esc(s.tiles ?? tiles.length) + ' tiles · source=' +
-      esc(source.state || 'UNKNOWN') + ' · operational=' +
-      esc(readiness.state || 'UNKNOWN');
+    el.textContent = 'live · composed from ' + esc(MANIFEST_EP) +
+      ' · ' + esc(s.tiles ?? tiles.length) + ' tiles · all_sources_live=' +
+      esc(String(s.all_sources_live));
     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.';

pages/hatun-mcp.html

@@ -9,7 +9,7 @@ a{color:var(--gold);text-decoration:none}a:hover{text-decoration:underline}
 header{border-bottom:1px solid var(--line);padding:14px 22px;display:flex;align-items:center;gap:14px;background:linear-gradient(180deg,#10121b,#0a0b10)}
 header .brand{font-weight:700;letter-spacing:.5px;color:var(--gold);font-size:18px}
 header .tag{color:var(--mut);font-size:12px}
-nav{display:flex;flex-wrap:nowrap;gap:8px;padding:10px 22px;border-bottom:1px solid var(--line);background:var(--panel);overflow-x:auto;overscroll-behavior-inline:contain;scrollbar-width:thin}
+nav{display:flex;flex-wrap:wrap;gap:8px;padding:10px 22px;border-bottom:1px solid var(--line);background:var(--panel)}
 nav a{font-size:12.5px;padding:4px 10px;border:1px solid var(--line);border-radius:999px;color:var(--mut)}
 nav a:hover{border-color:var(--gold);color:var(--gold);text-decoration:none}
 nav a.active{background:var(--gold);color:#0a0b10;border-color:var(--gold);font-weight:600}
@@ -22,8 +22,6 @@ h1{font-size:26px;margin:0 0 4px;color:#fff}h2{font-size:18px;margin:28px 0 10px
 .grid a.tile:hover{border-color:var(--gold);text-decoration:none}
 .grid a.tile .t{color:var(--gold);font-weight:600;margin-bottom:4px}.grid a.tile .d{color:var(--mut);font-size:12.5px}
 table{width:100%;border-collapse:collapse;margin:12px 0;font-size:13.5px}
-.table-wrap{width:100%;overflow-x:auto;overscroll-behavior-inline:contain;-webkit-overflow-scrolling:touch}
-.table-wrap table{min-width:620px}
 th,td{text-align:left;padding:8px 10px;border-bottom:1px solid var(--line);vertical-align:top}
 th{color:var(--mut);font-weight:600;font-size:12px;text-transform:uppercase;letter-spacing:.4px}
 code,pre{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12.5px}
@@ -37,22 +35,12 @@ footer{border-top:1px solid var(--line);color:var(--mut);font-size:11.5px;paddin
 .statline b{color:var(--ink)}
 .tag2{display:inline-block;background:#1c2030;color:var(--mut);border:1px solid var(--line);border-radius:6px;padding:1px 7px;font-size:11px;margin-left:6px}
 .st{color:var(--amb);font-weight:600}
-@media(max-width:700px){
- header{padding:12px 14px;align-items:flex-start;flex-direction:column;gap:2px}
- nav{padding:9px 14px}
- main{padding:20px 14px 44px}
- h1{font-size:23px;line-height:1.25}
- .card{padding:15px}
- .statline{display:grid;grid-template-columns:1fr;gap:8px}
- pre{white-space:pre-wrap;overflow-wrap:anywhere}
- footer{padding:16px 14px}
-}
 </style></head><body>
 <header><span class="brand">a11oy</span><span class="tag">Brand Orchestration Layer · the one place to see everything</span></header>
 <nav><a href="/hub">Hub</a><a href="/a11oy.code">a11oy.code</a><a href="/docs">Docs</a><a href="/pricing">Pricing</a><a href="/api-keys">API Keys</a><a href="/sdk">SDK</a><a href="/status">Status</a><a href="/hatun-mcp" class="active">Hatun-MCP</a><a href="/observability">Observability</a><a href="/security">Security</a><a href="/compliance">Compliance</a><a href="/cued-engagement">Cued Engagement</a><a href="/uds">UDS</a><a href="/counter-uas">Counter-UAS</a><a href="/evidence">Evidence</a><a href="/upgrades">Upgrades</a><a href="/audit">Audit</a><a href="/gap-report">Gap Report</a></nav>
 <main>
 <h1>Hatun-MCP — agentic MCP server</h1>
-<p class="sub"><b>Hatun</b> (Quechua: <i>great / sovereign</i>) is the Model Context Protocol gateway for SZL capabilities. This page separates a reachable runtime declaration from execution and receipt evidence. A listed tool is not proof that it has run. Receipt and signer fields remain <b>UNKNOWN</b> or <b>UNAVAILABLE</b> until the read-only evidence endpoint observes an actual governed-run receipt.</p>
+<p class="sub"><b>Hatun</b> (Quechua: <i>great / sovereign</i>) is the Model Context Protocol gateway that exposes SZL's governed flagship capabilities to any MCP client (Claude Desktop, Cursor, custom agents). Every tool invocation passes the Yuyay-13 governance gate and emits a signed Khipu receipt. Anonymous calls are governed-but-declined (OWASP MCP07) — provide an SZL API key to execute. This tab probes the live server directly from your browser.</p>
 
 <div class="card">
   <div class="statline">
@@ -62,20 +50,20 @@ footer{border-top:1px solid var(--line);color:var(--mut);font-size:11.5px;paddin
     <span>Protocol: <b id="proto">—</b></span>
     <span>Probe latency: <b id="lat">—</b></span>
   </div>
-  <p class="sub" style="margin:12px 0 0">Runtime path: <code>/mcp/</code> (same origin) · Transport: JSON-RPC over HTTP (<code>POST /mcp/</code>). Availability, protocol revision, signer evidence, and receipt-chain evidence are populated only from successful reads below.</p>
+  <p class="sub" style="margin:12px 0 0">Endpoint: <code>https://szlholdings-a11oy.hf.space/mcp/</code> (canonical, live, same-origin) · Transport: JSON-RPC over Streamable HTTP (<code>POST /mcp/</code>) · MCP revision <code>2024-11-05</code><br><b>Note:</b> the standalone hatun-mcp Space is retired; a11oy now serves the canonical MCP directly at <code>/mcp/</code>.</p>
 </div>
 
-<h2>Tools declared (<span id="toolcount">—</span>) <span id="toolsource" class="pill a">STATIC FALLBACK</span></h2>
-<p class="sub">The initial rows are an explicitly labelled static fallback. A successful <code>GET /mcp/</code> replaces them with the runtime-declared catalog. Neither state is execution proof.</p>
-<div class="table-wrap"><table><thead><tr><th>Tool</th><th>Description</th><th>Evidence class</th></tr></thead><tbody id="tools"></tbody></table></div>
+<h2>Tools exposed (<span id="toolcount">16</span>)</h2>
+<p class="sub">Loaded live from the canonical <code>GET /mcp/</code> discovery card on this Space. These are the real governed tools exposed by the live MCP (call them with <code>POST /mcp/</code> JSON-RPC <code>tools/call</code>).</p>
+<table><thead><tr><th>Tool</th><th>Backend flagship</th><th>Class</th></tr></thead><tbody id="tools"></tbody></table>
 
 <h2>Recent invocations</h2>
-<p class="sub">This bounded, ephemeral feed contains only summaries of governed agent runs for which this process actually created a receipt. It does not claim that every MCP discovery or tool call is signed, and reading it never mints a receipt.</p>
-<div class="table-wrap"><table><thead><tr><th>Time (UTC)</th><th>Observed tool</th><th>Outcome</th><th>Receipt evidence</th></tr></thead><tbody id="inv"><tr><td colspan="4" class="sub">loading…</td></tr></tbody></table></div>
+<p class="sub">Each MCP call appends a Khipu receipt (continuum hash + DSSE signature) to the governance chain. Recent receipts are summarized here from the server's invocation feed; if the feed endpoint is unreachable cross-origin it shows the honest interim message below.</p>
+<table><thead><tr><th>Time (UTC)</th><th>Tool</th><th>Outcome</th><th>Continuum hash</th></tr></thead><tbody id="inv"><tr><td colspan="4" class="sub">loading…</td></tr></tbody></table>
 
 <h2>Connect a client</h2>
 <div class="card">
-<p style="margin:0 0 8px">Claude Desktop — deployment example using the <code>mcp-remote</code> bridge. Verify the target URL and authentication requirements in your environment before use:</p>
+<p style="margin:0 0 8px">Claude Desktop — add to <code>claude_desktop_config.json</code> (uses the <code>mcp-remote</code> bridge, pointing at a11oy's live canonical <code>/mcp/</code>):</p>
 <pre>{
   "mcpServers": {
     "szl-a11oy": {
@@ -84,61 +72,63 @@ footer{border-top:1px solid var(--line);color:var(--mut);font-size:11.5px;paddin
     }
   }
 }</pre>
-<p class="sub" style="margin:8px 0 0">Same-origin checks: <code>GET /mcp/</code> for runtime discovery, <code>GET /api/hatun/evidence</code> for the no-mint evidence contract, and <code>GET /api/hatun/invocations</code> for observed receipt summaries. A public-key path alone is not proof that any receipt was signed.</p>
+<p class="sub" style="margin:8px 0 0">Quick test: <code>curl -s https://szlholdings-a11oy.hf.space/mcp/</code> (discovery card) or <code>curl -s -X POST https://szlholdings-a11oy.hf.space/mcp/ -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'</code> · public key: <a href="/cosign.pub" target="_blank" rel="noopener">/cosign.pub</a> · try the loop: <a href="/ask-and-act">/ask-and-act</a></p>
 </div>
 
-<div class="note">The page performs read-only same-origin probes. <code>GET /mcp/</code> supplies runtime declarations; <code>GET /api/hatun/evidence</code> supplies observed receipt state. Neither GET signs, appends, or upgrades evidence.</div>
-<p class="sub">Source: <code>szl_agentic_loop.py</code> · read-only probes of <code>/mcp/</code> and <code>/api/hatun/evidence</code></p>
+<div class="note">This tab probes a11oy's own canonical, same-origin <code>/mcp/</code> endpoint — no cross-origin CORS, no dead Space. The tool list and protocol version below are read live from <code>GET /mcp/</code>.</div>
+<p class="sub">Source: szl_agentic_loop.py (canonical MCP + governed loop) · live probe of <code>/mcp/</code></p>
 
 <script>
-const BASE="";
-const FALLBACK_TOOLS=[
- {name:"retrieve_context",description:"Governance-corpus retrieval declaration"},
- {name:"policy_check",description:"Deny-by-default policy declaration"},
- {name:"trust_score",description:"Advisory trust-score declaration"},
- {name:"sign_receipt",description:"Receipt-signing declaration"},
- {name:"verify_receipt",description:"Receipt-verification declaration"}
-];
-
-function cell(text,tag){const el=document.createElement(tag||'td');el.textContent=text==null?'—':String(text);return el;}
-function pill(text,cls){const el=document.createElement('span');el.className='pill '+cls;el.textContent=text;return el;}
-function setStatus(id,text,cls){const host=document.getElementById(id);host.textContent='';host.appendChild(pill(text,cls));}
-function paintTools(list,evidenceClass){const tb=document.getElementById('tools');tb.textContent='';
- list.forEach(tool=>{const tr=document.createElement('tr');const name=cell(tool.name,'td');
-  const code=document.createElement('code');code.textContent=tool.name||'—';name.textContent='';name.appendChild(code);
-  tr.appendChild(name);tr.appendChild(cell(tool.description||tool.title||'No description reported'));
-  const status=cell('','td');status.appendChild(pill(evidenceClass,evidenceClass==='RUNTIME DECLARED'?'n':'a'));tr.appendChild(status);tb.appendChild(tr);});
+const BASE="";  // same-origin: a11oy serves the canonical /mcp/ directly
+// Static authoritative tool list (mirrors server-card.json); refreshed live below when CORS permits.
+const TOOLS=[
+ ["szl_a11oy_code_chat","a11oy.code","read"],
+ ["szl_killinchu_detect","vessels / killinchu","read"],
+ ["szl_killinchu_cue","vessels / killinchu","2-person"],
+ ["szl_sentra_scan","sentra","read"],
+ ["szl_rosie_reason","rosie","read"],
+ ["szl_khipu_verify","governance","read"],
+ ["szl_lean_verify","lean / formal-verification","read"],
+ ["szl_puriq_evaluate","puriq","read"],
+ ["szl_yachay_dome_predict","yachay-dome","read"],
+ ["szl_wayra_recent","wayra","read"],
+ ["szl_anatomy_3d_render","anatomy","read"],
+ ["szl_doctrine_lookup","governance / doctrine","read"],
+ ["szl_yuyay_score","yuyay-v3","read"],
+ ["szl_thesis_query","thesis","read"],
+ ["szl_drone_lookup","uds / counter-uas","read"],
+ ["szl_formula_evaluate","puriq / formal math","read"]];
+function paintTools(list){const tb=document.getElementById('tools');tb.innerHTML='';
+ list.forEach(([n,b,c])=>{const tr=document.createElement('tr');
+  const cls=c==='2-person'?'a':'n';
+  tr.innerHTML=`<td><code>${n}</code></td><td>${b}</td><td><span class="pill ${cls}">${c}</span></td>`;tb.appendChild(tr);});
  document.getElementById('toolcount').textContent=list.length;}
-paintTools(FALLBACK_TOOLS,'STATIC FALLBACK');
+paintTools(TOOLS);
 
+// Live probe of the canonical, same-origin /mcp/ discovery card
 const t0=performance.now();
-fetch(BASE+"/mcp/",{cache:'no-store'}).then(r=>r.json().then(j=>({r,j}))).then(({r,j})=>{
- document.getElementById('lat').textContent=Math.round(performance.now()-t0)+' ms';
- setStatus('health',r.ok?'REACHABLE':'HTTP '+r.status,r.ok?'g':'a');
- document.getElementById('proto').textContent=j.protocolVersion||'UNKNOWN';
- if(r.ok&&j&&Array.isArray(j.tools)){
-   paintTools(j.tools,'RUNTIME DECLARED');
-   const source=document.getElementById('toolsource');source.className='pill n';source.textContent='RUNTIME DECLARED';
+fetch(BASE+"/mcp/").then(r=>r.json().then(j=>({r,j}))).then(({r,j})=>{
+ const ms=Math.round(performance.now()-t0);
+ document.getElementById('lat').textContent=ms+' ms';
+ document.getElementById('health').innerHTML=(r.ok&&j.canonical)?'<span class="pill g">LIVE</span>':'<span class="pill a">'+r.status+'</span>';
+ document.getElementById('signer').textContent='in-image ECDSA-P256 (see /cosign.pub)';
+ document.getElementById('chain').textContent='hash-chained receipts ✓';
+ document.getElementById('proto').textContent=j.protocolVersion||'—';
+ // refresh the tool table from the live card's real governed tools
+ if(j&&Array.isArray(j.tools)&&j.tools.length){
+   paintTools(j.tools.map(t=>[t.name, (t.title||'governed tool'), 'governed']));
  }
-}).catch(()=>{setStatus('health','UNAVAILABLE','r');document.getElementById('lat').textContent='UNAVAILABLE';});
-
-fetch(BASE+"/api/hatun/evidence",{cache:'no-store'}).then(r=>r.ok?r.json():Promise.reject()).then(e=>{
- const signer=e&&e.signer||{};const chain=e&&e.receipt_chain||{};
- document.getElementById('signer').textContent=signer.status==='OBSERVED_VERIFIED'?(signer.label||'OBSERVED_VERIFIED'):(signer.status||'UNKNOWN');
- document.getElementById('chain').textContent=chain.status||'UNKNOWN';
-}).catch(()=>{document.getElementById('signer').textContent='UNAVAILABLE';document.getElementById('chain').textContent='UNAVAILABLE';});
+}).catch(()=>{document.getElementById('health').innerHTML='<span class="pill r">unreachable</span>';});
 
-function paintEmptyInvocation(message){const tb=document.getElementById('inv');tb.textContent='';const tr=document.createElement('tr');
- const td=cell(message,'td');td.colSpan=4;td.className='sub';tr.appendChild(td);tb.appendChild(tr);}
-fetch(BASE+"/api/hatun/invocations",{cache:'no-store'}).then(r=>r.ok?r.json():Promise.reject()).then(feed=>{
- const items=feed&&Array.isArray(feed.items)?feed.items:[];const tb=document.getElementById('inv');tb.textContent='';
- if(!items.length){paintEmptyInvocation('UNKNOWN — no governed-run receipt has been observed in this process.');return;}
- items.slice(0,12).forEach(x=>{const tr=document.createElement('tr');tr.appendChild(cell(x.ts));
-  const tool=cell('','td'),code=document.createElement('code');code.textContent=x.tool||'—';tool.appendChild(code);tr.appendChild(tool);
-  const outcome=cell('','td');outcome.appendChild(pill(x.outcome||'UNKNOWN',x.outcome==='DENY'?'r':'a'));tr.appendChild(outcome);
-  const ev=cell('','td'),evCode=document.createElement('code');evCode.textContent=(x.signature_status||'UNKNOWN')+' · '+(x.receipt_hash||'').slice(0,16);ev.appendChild(evCode);tr.appendChild(ev);tb.appendChild(tr);});
-}).catch(()=>{paintEmptyInvocation('UNAVAILABLE — the read-only invocation feed could not be read.');});
+// Recent invocations feed (optional endpoint; honest fallback if absent/blocked)
+fetch(BASE+"/api/hatun/invocations",{mode:'cors'}).then(r=>r.ok?r.json():Promise.reject()).then(rows=>{
+ const tb=document.getElementById('inv');tb.innerHTML='';
+ if(!rows||!rows.length){tb.innerHTML='<tr><td colspan="4" class="sub">No recent invocations recorded.</td></tr>';return;}
+ rows.slice(0,12).forEach(x=>{const tr=document.createElement('tr');
+  const ok=x.outcome==='success';
+  tr.innerHTML=`<td>${x.ts||'—'}</td><td><code>${x.tool||'—'}</code></td><td><span class="pill ${ok?'g':'a'}">${x.outcome||'—'}</span></td><td><code>${(x.continuum_hash||'').slice(0,16)}</code></td>`;tb.appendChild(tr);});
+}).catch(()=>{document.getElementById('inv').innerHTML='<tr><td colspan="4" class="sub">Run a governed agent at <a href="/ask-and-act">/ask-and-act</a> — each run produces a signed, hash-chained receipt you can re-verify in the browser (chain + signature). The MCP <code>tools/call</code> path drives the same governed pipeline.</td></tr>';});
 </script>
 </main>
-<footer>Doctrine v11 honesty boundary · tool catalog = runtime declaration, not execution proof · signer and receipt-chain state remain UNKNOWN or UNAVAILABLE until observed evidence exists · GET reads never mint receipts</footer>
+<footer>Doctrine v12 (PURIQ) additive · v11/v12 LOCKED: 749 declarations · 14 axioms · 163 sorries · 13-axis yuyay_v3 · lutar-v18.0.0 @ c7c0ba17 · SLSA L1 (honest) · Khipu signature = DSSE/cosign PLACEHOLDER<br>HfApi direct push only · IP-HOLD a11oy#57 untouched · ADDITIVE / zero-regression · Khipu receipt on every action · Signed <b>Yachay</b> · Co-author Perplexity Computer Agent</footer>
 </body></html>

serve.py

@@ -77,13 +77,8 @@ def gov_envelope(payload=None, status="REAL", citations=None, reason=None, **ext
     return out
 # === END GOVERNED ENVELOPE ===
 
-# 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
+# RESET: SPA is served from /app/static (repo root mirrors dist/public). No /console subdir.
+STATIC_DIR = Path("/app/static")
 ASSETS_DIR = STATIC_DIR / "assets"
 INDEX_HTML = STATIC_DIR / "index.html"
 A11OY_BACKEND_PORT = 8081
@@ -1825,18 +1820,6 @@ 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/*:
@@ -3272,18 +3255,6 @@ 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
@@ -3491,9 +3462,7 @@ except Exception as _sec_hdr_e:  # pragma: no cover
 # ===========================================================================
 from fastapi.responses import RedirectResponse as _PTG_Redirect
 
-_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
+_PTG_WEB = Path("/app/web")
 
 def _ptg_serve(filename: str):
     async def _h() -> Response:

szl_agentic_loop.py

@@ -10,11 +10,9 @@
 # chained, signed receipt.
 #
 # WHAT IT EXPOSES (all registered BEFORE the SPA catch-all via routes.insert(0)):
-#   GET  /mcp/                          — MCP runtime discovery (declaration only)
+#   GET  /mcp/                          — MCP discovery card (canonical live MCP)
 #   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)
@@ -38,17 +36,10 @@ 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
@@ -756,14 +747,9 @@ 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):
@@ -837,7 +823,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 registered MCP) ----
+        # ---- HOP 3: MCP tool-call (policy_check tool, via the canonical MCP) ----
         with tr.span("tool_call", "mcp") as sp:
             tool_name = "policy_check"
             tool_input = {"action": action, "severity": severity,
@@ -1037,7 +1023,6 @@ 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.
@@ -1103,12 +1088,11 @@ def register(app, ns: str, sign_fn, verify_fn=None, pub_pem_fn=None,
                       "decision": decision}
         _RUN_CHAIN.append(run_record)
 
-        result = {
+        return {
             "run_id": tr.trace_id,
             "decision": decision,
             "emitted": effect["emitted"],
-            "summary": _plain_summary(decision, action, effect, reasons, trust, trust_pass,
-                                      receipt_has_signature),
+            "summary": _plain_summary(decision, action, effect, reasons, trust, trust_pass),
             "retrieved": chunks,
             "untrusted": {"present": bool(untrusted_input),
                           "excerpt": (untrusted_input or "")[:240],
@@ -1134,34 +1118,25 @@ 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 if receipt_has_signature else None,
-            "signer_claim_status": ("SIGNATURE_PRESENT_UNVERIFIED"
-                                    if receipt_has_signature else "UNAVAILABLE"),
+            "signer": signer_label,
             "verify_hint": ("Re-verify with POST /api/%s/v1/agent/verify-chain "
-                            "(send the whole run object back). A signature is not called "
-                            "valid until that verifier succeeds." % ns),
+                            "(send the whole run object back). The final receipt is "
+                            "signed; fetch /cosign.pub to verify offline." % ns),
             "doctrine": "v11",
             "honesty": ("Trust score is advisory (Conjecture 1). RAG retrieves over the "
-                        "in-image governance corpus. Receipt signature state is %s."
-                        % ("PRESENT_UNVERIFIED" if receipt_has_signature else "UNAVAILABLE")),
+                        "in-image governance corpus. The receipt is %s." % signer_label),
         }
-        _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.")
+
+    def _plain_summary(decision, action, effect, reasons, trust, trust_pass):
         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. %s"
-                    % (trust, action, effect["effect"], receipt_note))
+                    "%.2f), the action \"%s\" was %s. A signed receipt was produced."
+                    % (trust, action, effect["effect"]))
         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. %s This is the gate working."
-                % (action, why, receipt_note))
+                "taken — only a signed deny receipt was produced. This is the gate working."
+                % (action, why))
 
     def _verify_chain(run: dict):
         """Re-verify a run object: (1) chain integrity (each prev_hash links and each
@@ -1213,122 +1188,6 @@ 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,
@@ -1539,7 +1398,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 (runtime-declared MCP surface) ----
+    # ---- MCP JSON-RPC handler (canonical live MCP) ----
     async def _mcp_post(request: Request):
         try:
             body = await request.json()
@@ -1637,21 +1496,18 @@ 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):
-        # The response proves this route was reachable for this request. Its tool
-        # list remains a runtime declaration, not proof of tool execution.
+        # MCP discovery card — proves a real, live, canonical MCP surface.
         return JSONResponse({
             "name": "szl-%s-mcp" % ns,
-            "title": "SZL %s — governed MCP runtime" % ns,
+            "title": "SZL %s — canonical governed MCP" % 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)),
-            "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."),
+            "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),
             "doctrine": "v11",
         })
 
@@ -1673,17 +1529,7 @@ 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)),
-                             "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"})
+                             "canonical_mcp": "/mcp/", "doctrine": "v11"})
 
     async def _agent_governance_standards(request: Request):
         return JSONResponse(governance_standards_note())
@@ -1749,10 +1595,6 @@ 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),
@@ -1760,13 +1602,6 @@ 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()         (tamper-evident chain)
+  * energy ledger    — szl_energy_ledger.handle_ledger()         (signed receipt 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 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 #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 composition is the whole point: SZL already holds the parts (tamper-evident
-energy receipts MEASURED, signed UDS bundle MEASURED, governance doctrine MEASURED, MODELED
+The composition is the whole point: SZL already holds the parts (signed 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 a COMPUTED integrity
+# pastes ANY receipt digest from ANY organ and gets an INDEPENDENT, COMPUTED
 # 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,115 +105,6 @@ 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.
 # ---------------------------------------------------------------------------
@@ -243,11 +134,6 @@ 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"],
-        },
     )
 
 
@@ -265,16 +151,14 @@ 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} integrity-only receipts, links_intact={links_intact})"
+    status = (f"OK ({chain_len} signed receipts, links_intact={links_intact})"
               if chain_len else "IDLE (chain empty — no jobs minted yet)")
     return _tile(
-        "Tamper-evident energy ledger", "energy", status=status, label=MEASURED,
+        "Signed energy ledger", "energy", status=status, label=MEASURED,
         provenance={
             "endpoint": f"{_API}/energy/ledger",
-            "kind": ("tamper-evident integrity-only JouleCharge hash chain; "
-                     "no cryptographic signature is verified by this surface"),
+            "kind": "hash-chained JouleCharge receipt chain",
             "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
@@ -288,17 +172,6 @@ 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
-            ],
-        },
     )
 
 
@@ -306,8 +179,7 @@ def _tile_energy_provenance() -> dict:
     import szl_energy_provenance as ep
     summ = ep._CHAIN.summary()
     length = summ.get("length", 0)
-    verify = summ.get("verify", {}) or {}
-    status = (f"INTEGRITY-VERIFIED ({length} tamper-evident receipts)" if length
+    status = (f"VERIFIED ({length} tamper-evident receipts)" if length
               else "EMPTY (no receipts this process)")
     return _tile(
         "Energy provenance chain", "provenance", status=status, label=MEASURED,
@@ -316,24 +188,12 @@ 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,
-        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
-            ],
-        },
+        chain_status=summ.get("status"),
     )
 
 
@@ -359,11 +219,6 @@ 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"],
-        },
     )
 
 
@@ -388,11 +243,6 @@ 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"],
-        },
     )
 
 
@@ -421,11 +271,6 @@ 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"],
-        },
     )
 
 
@@ -436,50 +281,35 @@ 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=status,
+        "Governance / restraint", "governance", status="OK (codified doctrine + signed receipts)",
         label=MEASURED,
         provenance={
             "endpoint": f"{_API}/restraint/info",
-            "kind": ("codified restraint policy metadata; operational status additionally "
-                     "requires observed signer health and cryptographic receipt verification"),
+            "kind": "codified restraint ladder; each decision -> a signed DSSE receipt",
             "doctrine_version": doctrine.get("version"),
             "kernel_commit": doctrine.get("kernel_commit"),
         },
-        signed_receipts_declared=doctrine.get("signed_receipts"),
-        signer_health=crypto_evidence,
-        signature_required=True,
-        signature_verified=crypto_ready,
+        signed_receipts=doctrine.get("signed_receipts"),
         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).
 
-    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 +
+    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 +
     PAC-Bayes bound + MEASURED/MODELED/SAMPLE energy label + governed model identity + Lean
-    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
+    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
     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 is UNAVAILABLE, awaiting a real governed write."""
+    the tile says so honestly (ROADMAP, awaiting first real action)."""
     import szl_khipu
     import szl_provenance_receipt as pr
 
@@ -490,61 +320,30 @@ 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
-    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).")
+    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.")
         label = MEASURED
-        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 "
+        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 "
                 "MEASURED/MODELED/SAMPLE energy label, the governed model identity, and the "
-                "exact Lean backing. Each part KEEPS its own label; no label is upgraded. "
-                "This tile READS the chain — it does "
+                "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 "
                 "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 = ("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 "
+        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 "
                 "/provenance/receipt (immune verdict + PAC-Bayes bound + energy label + "
                 "governed model identity + Lean backing) — never fabricated, never minted by "
                 "loading this manifest.")
@@ -553,9 +352,10 @@ def _concept_tile_inference_provenance() -> dict:
         "Composite inference-provenance receipt", "frontier-concept",
         status=status, label=label,
         provenance={
-            "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"),
+            "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",
             "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
@@ -568,36 +368,16 @@ 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",
-            "open_dependencies": f"{_API}/materials/certify (PAC-Bayes/Lean evidence must "
-                                 "retain the status reported by that dependency)",
+            "composes_roadmap": f"{_API}/materials/certify (PAC-Bayes bound; Lean SORRY/ROADMAP)",
         },
         # 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
-            ],
-        },
     )
 
 
@@ -606,7 +386,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, "Tamper-evident energy ledger", "energy",
+    (_tile_energy_ledger, "Signed energy ledger", "energy",
      {"endpoint": f"{_API}/energy/ledger"}),
     (_tile_energy_provenance, "Energy provenance chain", "provenance",
      {"endpoint": f"{_API}/energy/provenance"}),
@@ -650,8 +430,7 @@ def _build_manifest() -> dict:
         tiles.append(tile if tile is not None
                      else _unavailable_tile(name, category, prov, err or "unknown error"))
 
-    # Composite capability — always present, but UNAVAILABLE until a real write has
-    # minted an artifact. A manifest read never creates operational evidence.
+    # #1 frontier play — always present, always ROADMAP, never a fabricated artifact.
     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",
@@ -662,79 +441,47 @@ 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 own honesty label and "
+                 "capability as a tile with its MEASURED/MODELED/ROADMAP/SAMPLE 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 composite receipt remains "
-            "UNAVAILABLE until a real governed write has minted an artifact. "
+            "UNAVAILABLE tile, never a fabricated OK. The #1 frontier composite receipt is a "
+            "ROADMAP concept that names its parts — no composite artifact is minted. "
             "Λ = Conjecture 1."
         ),
         "universal_verifier": {
-            "what": "judge-facing integrity layer: paste ANY receipt digest from ANY shared "
+            "what": "judge-facing audit layer: paste ANY receipt digest from ANY shared "
                     "szl_khipu organ (immune, materials, kverify, provenance, sda, "
-                    "nemo_agents) and get a COMPUTED hash-chain PASS|FAIL|NOT_FOUND",
+                    "nemo_agents) and get an INDEPENDENT, COMPUTED PASS|FAIL|NOT_FOUND",
             "verify_post": _KHIPU_VERIFY,
             "verify_link": _KHIPU_VERIFY_PATH,
             "organs": _KHIPU_ORGANS,
-            "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"),
+            "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)",
         },
         "labels_legend": {
-            "MEASURED": ("real measured/shipped capability (e.g. tamper-evident joule "
-                         "receipts, REAL probes); MEASURED never implies signed"),
+            "MEASURED": "real measured/shipped capability (e.g. signed joule receipts, REAL probes)",
             "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": "source, dependency, or required artifact unavailable right now",
+            "UNAVAILABLE": "sub-source down right now — reported honestly, not faked",
         },
         "summary": {
             "tiles": len(tiles),
             "label_counts": label_counts,
             "degraded_tiles": degraded,
-            "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,
-            },
+            "all_sources_live": len(degraded) == 0,
         },
         "capabilities": tiles,
         "timestamp_utc": _now_iso(),
@@ -827,7 +574,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 UNAVAILABLE / no-artifact; building the manifest must not grow it.
+    #    tile is honestly ROADMAP / 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")
@@ -837,11 +584,10 @@ 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 (UNAVAILABLE, MEASURED), concept["label"]
-    # On a fresh process (empty chain) the tile is honestly UNAVAILABLE with no artifact.
+    assert concept["label"] in (ROADMAP, MEASURED), concept["label"]
+    # On a fresh process (empty chain) the tile is honestly ROADMAP with no artifact.
     if _before == 0:
-        assert concept["label"] == UNAVAILABLE, \
-            "empty chain -> honest UNAVAILABLE, no fabricated artifact"
+        assert concept["label"] == ROADMAP, "empty chain -> honest ROADMAP, 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"
@@ -850,8 +596,6 @@ 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) ---")
@@ -859,3 +603,5 @@ 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 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.
+  * 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.
   * No fabricated metric. No live-trading claim. No backtest claim. cuML speedups are
     cited to NVIDIA/STAC docs, never asserted as SZL-measured.
 
@@ -41,7 +41,7 @@ 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 DSSE-bearing SAMPLE receipt
+  GET  /api/{ns}/v1/quant/pipeline   — full 3-layer pass + ONE signed 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 — NVIDIA datasheet vs SZL-MEASURED (honest, empty/ROADMAP)
   GET  /quant                        — unified mobile-first "Quant Engine" tab (0 CDN)
@@ -50,12 +50,10 @@ 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 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
@@ -63,7 +61,6 @@ from datetime import datetime, timezone
 # --- 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
@@ -82,9 +79,6 @@ 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) ------------------------
@@ -670,10 +664,10 @@ def layer3_hjb_kelly(l1=None, l2=None, gamma=0.5, kappa=1.0, stress=False):
 
 
 # =====================================================================================
-# FULL PIPELINE -> ONE DSSE-bearing SAMPLE receipt.
+# FULL PIPELINE -> ONE signed SAMPLE receipt.
 # =====================================================================================
 def run_pipeline(stress=False, gamma=0.5, kappa=1.0) -> dict:
-    """Full 3-layer pass plus a DSSE envelope whose signature state is explicit."""
+    """Full 3-layer pass + a single SIGNED SAMPLE receipt (DSSE over canonical JSON)."""
     returns = _sample_returns(stress=stress)
     l1 = layer1_pca_risk(returns=returns, stress=stress)
     l2 = layer2_tda_fracture(returns=returns, stress=stress)
@@ -821,7 +815,7 @@ def tiers_panel() -> dict:
 # =====================================================================================
 # VERIFY-THE-CLAIMS panel: NVIDIA datasheet vs SZL-MEASURED (honest; empty/ROADMAP).
 # =====================================================================================
-def _legacy_verify_claims_panel() -> dict:
+def 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."""
@@ -861,366 +855,6 @@ def _legacy_verify_claims_panel() -> dict:
     }
 
 
-# =====================================================================================
-# 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:
-    """Read a bounded local benchmark receipt without producing side effects.
-
-    Missing, semantically inconsistent, stale-looking, or tampered data never
-    becomes a live claim. Valid old receipts remain visible as HISTORICAL.
-    """
-    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"],
-        "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,
-        "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(),
-    }
-
-
 # =====================================================================================
 # Unified "Quant Engine" HTML tab (0 CDN; window.SZLLabels).
 # =====================================================================================
@@ -1256,23 +890,10 @@ 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"]
-    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."
-    )
+    signed = dsse.get("signed", False)
     rc_body = (row("data source", "SAMPLE_SYNTHETIC")
                + row("pipeline", "<code>szl-gpu-quant-v0.1</code>")
-               + row("signature state", pipeline_signature_state)
+               + row("DSSE signed", fmt(signed))
                + row("PAE sha256", "<code>%s…</code>" % str(dsse.get("_pae_sha256", ""))[:16])
                + row("label", "<small>%s</small>" % SAMPLE_LABEL))
 
@@ -1290,27 +911,19 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
 
     vrows = ""
     for r in verify["rows"]:
-        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 "—"))
+        vrows += ('<tr><td>%s</td><td class="ds">%s</td><td class="ms"><span class="pill-slot" '
+                  'data-label="%s"></span> %s</td></tr>' % (
+                      r["claim"], r["nvidia_datasheet"], r["szl_label"], fmt(r["szl_measured"])))
+    verify_tbl = ('<table class="vt"><thead><tr><th>Claim</th><th>NVIDIA datasheet</th>'
+                  '<th>SZL-MEASURED (signed)</th></tr></thead><tbody>%s</tbody></table>' % vrows)
 
     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(pipeline_receipt_title, "SAMPLE", rc_body, pipeline_receipt_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).")),
     ])
 
     return """<!doctype html>
@@ -1346,15 +959,15 @@ 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 — 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="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="state">backend=__BACKEND__ · gpu_reachable=__REACH__ · scenario=__SCEN__</p>
 </header>
-<h2>3-Layer Pipeline (DSSE receipt: __PIPE_SIG__)</h2>
+<h2>3-Layer Pipeline (signed SAMPLE receipt)</h2>
 <section class="grid">__CARDS__</section>
 <h2>2-GPU Sovereign Serve · Throttle Both</h2>
 <section class="grid">__TIERS__</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>
+<h2>Verify the Claims — NVIDIA datasheet vs SZL-MEASURED (signed)</h2>
+<section>__VERIFY__<p class="note">__VNOTE__</p></section>
 <footer>
   <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>
@@ -1370,8 +983,7 @@ 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." :
-               (label === "NOT_MEASURED") ? "No valid execution receipt is loaded; no value is invented." :
-               "Capability state reported by the live surface."});
+               "Wiring ready; not measured yet. ROADMAP, never faked."});
     }
     return '<span>' + label + '</span>';
   }
@@ -1381,15 +993,13 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
 })();
 </script>
 </body></html>""" \
-        .replace("__SUMMARY__", "Operational bounded quant pipeline; CPU reference measured, GPU comparison requires a kernel receipt") \
+        .replace("__SUMMARY__", "VRAM-resident quant pipeline (honest CPU fallback today; GPU path ROADMAP)") \
         .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"])) \
@@ -1489,11 +1099,10 @@ def _selftest() -> dict:
         assert t["sovereign"] == tp["gpu_reachable"], t
     out["tiers_sovereign_honest"] = True
 
-    # (f) Verify-claims: without a receipt no measured number is invented.
+    # (f) Verify-claims: SZL-MEASURED column is empty/ROADMAP (never the datasheet number).
     vc = verify_claims_panel()
-    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
+    assert all(r["szl_measured"] is None and r["szl_label"] == "ROADMAP" for r in vc["rows"]), vc
+    out["verify_claims_roadmap"] = True
 
     # (g) HTML renders, non-trivial, no forbidden raw claims.
     h = _html(pipe, tp, vc)

web/immune.html

@@ -4,7 +4,7 @@
 <meta charset="UTF-8"/>
 <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
 <title>Immune (Hukulla) — fail-closed egress gate · SZL Holdings</title>
-<meta name="description" content="Honest operational view of the Immune organ (Quechua role 'Hukulla') — a fail-closed, deny-by-default egress gate. Status, trace, signature, and Khipu-chain evidence are shown only when returned by the live backend. Lambda = Conjecture 1; Khipu = Conjecture 2; trust never 100%."/>
+<meta name="description" content="Live, honest view of the Immune organ (Quechua role 'Hukulla') — a fail-closed, deny-by-default egress gate. Real threat-signature scan + 1 MB size guard + Lambda-gate floor, every verdict signed into the shared Khipu chain. Lean backing: ImmuneNeymanPearsonOpt + FrontierWelfordVariance. Lambda = Conjecture 1; Khipu = Conjecture 2; trust never 100%."/>
 <!-- 0 runtime CDN (doctrine v11): system fonts only — no Google Fonts, no external assets. -->
 <style>
 :root{
@@ -26,9 +26,7 @@ a{color:inherit;text-decoration:none;}
 .topbar{position:sticky;top:0;z-index:60;display:flex;align-items:center;gap:1rem;flex-wrap:wrap;padding:.5rem 1.1rem;background:rgba(10,10,10,.92);backdrop-filter:blur(10px);border-bottom:1px solid var(--gold-line);font-family:var(--mono);font-size:10.5px;letter-spacing:.1em;text-transform:uppercase;color:var(--gold);}
 .topbar .sep{color:var(--dim);}
 .topbar .live{display:inline-flex;align-items:center;gap:.4rem;color:var(--cream);}
-.live-dot{width:6px;height:6px;border-radius:50%;background:var(--warn);box-shadow:0 0 6px var(--warn);animation:pulse 2.2s ease-in-out infinite;}
-.live-dot.ready{background:var(--live);box-shadow:0 0 6px var(--live);}
-.live-dot.error{background:var(--err);box-shadow:0 0 6px var(--err);animation:none;}
+.live-dot{width:6px;height:6px;border-radius:50%;background:var(--live);box-shadow:0 0 6px var(--live);animation:pulse 2.2s ease-in-out infinite;}
 @keyframes pulse{0%,100%{opacity:1;}50%{opacity:.35;}}
 .switcher{margin-left:auto;display:flex;align-items:center;gap:.3rem;}
 .flag{padding:.22rem .55rem;border-radius:6px;border:1px solid transparent;color:var(--muted);transition:.15s;}
@@ -39,13 +37,12 @@ h1{font-size:1.7rem;font-weight:600;margin:.2rem 0 .3rem;letter-spacing:-.01em;}
 .badge{display:inline-block;font-family:var(--mono);font-size:10px;letter-spacing:.08em;text-transform:uppercase;color:var(--teal);border:1px solid var(--teal-line);background:var(--teal-soft);padding:.25rem .6rem;border-radius:5px;margin-left:.4rem;vertical-align:middle;}
 .lede{color:var(--paragraph);font-size:.95rem;line-height:1.65;max-width:1180px;margin:.6rem 0 1rem;}
 .lede b{color:var(--cream);font-weight:600;}
-.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,220px),1fr));gap:.8rem;margin:0 0 1.2rem;}
+.cards{display:grid;grid-template-columns:repeat(4,1fr);gap:.8rem;margin:0 0 1.2rem;}
 .card{border:1px solid var(--gold-line);background:var(--panel);border-radius:8px;padding:.85rem 1rem;}
 .card .lbl{font-family:var(--mono);font-size:9.5px;letter-spacing:.1em;text-transform:uppercase;color:var(--dim);}
 .card .big{font-size:1.5rem;font-weight:600;margin:.35rem 0 .15rem;color:var(--teal);}
 .card .sub{font-family:var(--mono);font-size:10.5px;color:var(--muted);}
-.grid2{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:1rem;}
-.grid2>*{min-width:0;}
+.grid2{display:grid;grid-template-columns:1fr 1fr;gap:1rem;}
 .panel{border:1px solid var(--gold-line);background:var(--panel);border-radius:10px;padding:1rem 1.1rem;margin-bottom:1rem;}
 .panel h2{font-size:1.05rem;font-weight:600;margin:0 0 .2rem;display:flex;align-items:center;justify-content:space-between;}
 .panel h2 .meta{font-family:var(--mono);font-size:10px;color:var(--dim);text-transform:uppercase;letter-spacing:.06em;}
@@ -59,8 +56,6 @@ h1{font-size:1.7rem;font-weight:600;margin:.2rem 0 .3rem;letter-spacing:-.01em;}
 .pill.dim{color:var(--muted);}
 .simnote{border:1px solid var(--warn);background:rgba(201,160,95,.06);border-radius:8px;padding:.7rem .9rem;margin-top:.8rem;font-family:var(--mono);font-size:11px;color:#d8c39a;line-height:1.65;}
 table{width:100%;border-collapse:collapse;font-family:var(--mono);font-size:11.5px;margin-top:.5rem;}
-.table-scroll{max-width:100%;overflow-x:auto;overscroll-behavior-inline:contain;-webkit-overflow-scrolling:touch;}
-.table-scroll table{min-width:680px;}
 th,td{text-align:left;padding:.34rem .5rem;border-bottom:1px solid var(--gold-soft);color:var(--paragraph);vertical-align:top;}
 th{color:var(--dim);text-transform:uppercase;letter-spacing:.06em;font-size:9.5px;}
 td.deny{color:var(--red);}td.allow{color:var(--green);}
@@ -68,7 +63,6 @@ textarea,input{width:100%;background:var(--panel2);border:1px solid var(--gold-l
 textarea:focus,input:focus{outline:none;border-color:var(--teal-line);}
 button.run{margin-top:.6rem;padding:.55rem 1.1rem;border-radius:7px;border:1px solid var(--teal-line);background:var(--teal-soft);color:var(--teal);font-family:var(--mono);font-size:12px;letter-spacing:.06em;text-transform:uppercase;cursor:pointer;transition:.15s;}
 button.run:hover{background:rgba(95,179,163,.18);color:var(--cream);}
-button.run:focus-visible,.preset:focus-visible,.flag:focus-visible{outline:2px solid var(--teal);outline-offset:2px;}
 .preset{display:inline-block;margin:.3rem .3rem 0 0;padding:.2rem .5rem;border-radius:5px;border:1px solid var(--gold-line);color:var(--muted);font-family:var(--mono);font-size:10.5px;cursor:pointer;}
 .preset:hover{color:var(--cream);border-color:var(--teal-line);}
 .verdict-box{margin-top:.8rem;border:1px solid var(--gold-line);border-radius:8px;padding:.85rem 1rem;background:var(--panel2);font-family:var(--mono);font-size:12px;line-height:1.8;}
@@ -78,33 +72,12 @@ button.run:focus-visible,.preset:focus-visible,.flag:focus-visible{outline:2px s
 .digest{color:var(--gold);word-break:break-all;}
 code{font-family:var(--mono);color:var(--teal);}
 .footnote{font-family:var(--mono);font-size:10px;color:var(--dim);margin-top:1.6rem;line-height:1.7;}
-@media(max-width:760px){
-  .topbar{position:static;padding:.55rem .8rem;gap:.55rem;}
-  .switcher{order:3;width:100%;margin-left:0;flex-wrap:nowrap;overflow-x:auto;overscroll-behavior-inline:contain;padding-bottom:.15rem;}
-  .flag{flex:0 0 auto;min-height:44px;display:inline-flex;align-items:center;}
-  .wrap{padding:1.15rem .85rem 3rem;}
-  h1{font-size:1.4rem;line-height:1.25;}
-  .badge{display:block;width:max-content;max-width:100%;margin:.55rem 0 0;white-space:normal;}
-  .grid2{grid-template-columns:minmax(0,1fr);}
-  .panel{padding:.85rem;}
-  .panel h2{align-items:flex-start;gap:.5rem;flex-direction:column;}
-  .kv .k{min-width:130px;}
-  button.run{min-height:44px;width:100%;}
-  .preset{min-height:44px;display:inline-flex;align-items:center;}
-}
-@media(max-width:420px){
-  .cards{grid-template-columns:minmax(0,1fr);}
-  .kv>div{display:grid;grid-template-columns:minmax(0,.7fr) minmax(0,1.3fr);gap:.5rem;}
-  .kv .k{min-width:0;}
-  .kv .v,.digest{overflow-wrap:anywhere;word-break:break-word;}
-}
-@media(prefers-reduced-motion:reduce){.live-dot{animation:none;}}
 </style>
 </head>
 <body>
 <div class="topbar">
   <span>SZL HOLDINGS</span><span class="sep">/</span><span>a11oy</span>
-  <span class="live"><span class="live-dot" id="liveDot"></span><span id="liveTag" aria-live="polite">IMMUNE · PROBING</span></span>
+  <span class="live"><span class="live-dot"></span><span id="liveTag">IMMUNE · LIVE</span></span>
   <span class="switcher">
     <a class="flag active" href="/immune">Immune</a>
     <a class="flag" href="/energy">Energy</a>
@@ -115,13 +88,12 @@ code{font-family:var(--mono);color:var(--teal);}
 </div>
 
 <div class="wrap">
-  <h1>Immune (Hukulla) — fail-closed egress gate<span class="badge" id="organBadge">deny-by-default · evidence pending</span></h1>
+  <h1>Immune (Hukulla) — fail-closed egress gate<span class="badge" id="organBadge">deny-by-default · real inspection · Khipu-signed</span></h1>
   <p class="lede">
     The <b>Immune</b> organ (Quechua role <b>Hukulla</b>) is a <b>fail-closed, deny-by-default</b> egress gate.
-    Submitted actions are sent to the live threat-signature, size, and
-    <b>&Lambda;-gate</b> inspection path (MIN of supplied trust axes &lt; 0.5 &rarr; deny). When the backend
-    returns a Khipu receipt, its digest, sequence, signature, chain result, and trace context are shown below.
-    No receipt or signature state is inferred by this page. Proven Lean backing:
+    Every action is inspected against a real threat-signature corpus, a 1&nbsp;MB size guard and a
+    <b>&Lambda;-gate floor</b> (MIN of supplied trust axes &lt; 0.5 &rarr; deny). Each verdict is signed into the
+    <b>shared Khipu chain</b> (<code>SZL.Immune.Verdict.v1</code>). Proven Lean backing:
     <code>ImmuneNeymanPearsonOpt.lean</code> (Neyman&ndash;Pearson-optimal egress) and
     <code>FrontierWelfordVariance.lean</code> (Welford online variance). These back the gate but are
     <b>not</b> folded into the locked-8 proven set. &Lambda; = <b>Conjecture&nbsp;1</b> (not a theorem);
@@ -139,7 +111,7 @@ code{font-family:var(--mono);color:var(--teal);}
     <div class="panel">
       <h2>Inspect an action <span class="meta" id="verdictEp">POST /api/a11oy/v1/immune/verdict</span></h2>
       <p class="lede" style="margin:.2rem 0 .6rem;font-size:.86rem;">
-        Submit an action payload to the live inspection endpoint. Returned receipt and signing evidence is shown without inference.
+        Submit a real action payload. The gate runs the live inspection and signs a Khipu receipt.
         Optionally include <code>axes</code> (a JSON array of trust scores) to exercise the &Lambda;-gate floor.
       </p>
       <div>
@@ -157,7 +129,7 @@ code{font-family:var(--mono);color:var(--teal);}
 
     <div class="panel">
       <h2>Live status <span class="meta" id="statusEp">GET /api/a11oy/v1/immune/status</span></h2>
-      <div class="kv" id="statusKv" aria-live="polite"><span class="k">status</span><span class="v">PROBING</span></div>
+      <div class="kv" id="statusKv"><span class="k">loading…</span></div>
       <div class="simnote" id="honestyNote">
         Λ = Conjecture 1 (NOT a theorem). Khipu = Conjecture 2. Trust never 100%. Effectors simulated.
         Decision feed is in-memory (resets on restart) — empty means IDLE, never faked.
@@ -167,12 +139,12 @@ code{font-family:var(--mono);color:var(--teal);}
 
   <div class="panel">
     <h2>Gates <span class="meta" id="gatesEp">GET /api/a11oy/v1/immune/gates</span></h2>
-    <div class="table-scroll" role="region" aria-label="Immune gates" tabindex="0"><table id="gatesTable"><thead><tr><th>id</th><th>name</th><th>label</th><th>category</th><th>sample → expected</th></tr></thead><tbody><tr><td class="mono" colspan="5">loading…</td></tr></tbody></table></div>
+    <table id="gatesTable"><thead><tr><th>id</th><th>name</th><th>label</th><th>category</th><th>sample → expected</th></tr></thead><tbody><tr><td class="mono" colspan="5">loading…</td></tr></tbody></table>
   </div>
 
   <div class="panel">
     <h2>Decision feed <span class="meta" id="feedEp">GET /api/a11oy/v1/immune/feed</span></h2>
-    <div class="table-scroll" role="region" aria-label="Immune decision feed" tabindex="0"><table id="feedTable"><thead><tr><th>time</th><th>decision</th><th>signals</th><th>Λ</th><th>receipt</th></tr></thead><tbody><tr><td class="mono" colspan="5">loading…</td></tr></tbody></table></div>
+    <table id="feedTable"><thead><tr><th>time</th><th>decision</th><th>signals</th><th>Λ</th><th>receipt</th></tr></thead><tbody><tr><td class="mono" colspan="5">loading…</td></tr></tbody></table>
   </div>
 
   <div class="footnote" id="leanFoot">
@@ -184,96 +156,45 @@ code{font-family:var(--mono);color:var(--teal);}
 
 <script>
 const BASE = "/api/a11oy/v1/immune";
-async function requestJSON(u,opt){
-  try{
-    const r=await fetch(u,opt);
-    const text=await r.text();
-    let data=null;
-    if(text){
-      try{data=JSON.parse(text);}
-      catch(e){return {ok:false,status:r.status,error:"invalid JSON response",data:null};}
-    }
-    if(!r.ok){
-      const detail=data&&(data.detail||data.error||data.message);
-      return {ok:false,status:r.status,error:detail||("HTTP "+r.status),data:data};
-    }
-    return {ok:true,status:r.status,error:null,data:data};
-  }catch(e){
-    return {ok:false,status:null,error:(e&&e.message)||String(e),data:null};
-  }
-}
+async function getJSON(u,opt){try{const r=await fetch(u,opt);if(!r.ok)return null;return await r.json();}catch(e){return null;}}
 function esc(s){return String(s).replace(/[&<>"']/g,function(c){return({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]||c);});}
-function evidenceValue(v){
-  if(typeof v==="string")return v;
-  try{return JSON.stringify(v);}catch(e){return String(v);}
-}
-function present(v){return v!==undefined&&v!==null&&v!=="";}
-function row(label,value,cls){
-  if(!present(value))return "";
-  return '<div><span class="k">'+esc(label)+'</span><span class="v '+(cls||'')+'">'+esc(evidenceValue(value))+'</span></div>';
-}
-function connectionState(state,reachable){
-  const normalized=present(state)?String(state).trim().toUpperCase():"UNKNOWN";
-  const ready=reachable&&["LIVE","REAL","READY","OPERATIONAL","MEASURED"].includes(normalized);
-  const dot=document.getElementById("liveDot");
-  dot.className="live-dot"+(ready?" ready":reachable?"":" error");
-  document.getElementById("liveTag").textContent="IMMUNE · "+(reachable?normalized:"UNAVAILABLE");
-  document.getElementById("organBadge").textContent=ready?"deny-by-default · backend reported "+normalized.toLowerCase():"deny-by-default · evidence "+(reachable?normalized.toLowerCase():"unavailable");
-  return {normalized,ready};
-}
-function requestFailure(result){
-  const status=result.status==null?"network error":"HTTP "+result.status;
-  return status+(present(result.error)?" · "+result.error:result.ok?" · required evidence unavailable":"");
-}
 
 async function loadStatus(){
-  const result = await requestJSON(BASE + "/status");
+  const s = await getJSON(BASE + "/status");
   const kv = document.getElementById("statusKv");
-  if(!result.ok||!result.data){
-    connectionState(null,false);
-    kv.innerHTML=row("status","UNAVAILABLE")+row("evidence",requestFailure(result));
-    return;
-  }
-  const s=result.data;
-  const state=connectionState(s.status,true);
-  document.getElementById("cVerdicts").textContent = (s.verdicts_this_process ?? "—");
+  if(!s){kv.innerHTML='<span class="k">status</span><span class="v">unreachable — retrying</span>';return;}
+  document.getElementById("cVerdicts").textContent = (s.verdicts_this_process ?? 0);
   document.getElementById("cDenyRate").textContent = (s.deny_rate==null?"—":(Math.round(s.deny_rate*1000)/10)+"%");
-  document.getElementById("cDenySub").textContent = (s.deny ?? "—")+" deny / "+(s.allow ?? "—")+" allow";
+  document.getElementById("cDenySub").textContent = (s.deny ?? 0)+" deny / "+(s.allow ?? 0)+" allow";
   document.getElementById("cCorpus").textContent = (s.signature_corpus_size ?? "—");
-  document.getElementById("cCorpusSub").textContent = (s.threats_corpus_total ?? "—")+" STIX/MITRE in corpus";
+  document.getElementById("cCorpusSub").textContent = (s.threats_corpus_total ?? 0)+" STIX/MITRE in corpus";
   const k = s.khipu||{};
   document.getElementById("cChain").textContent = (k.chain_depth ?? "—");
-  document.getElementById("cChainSub").textContent = (typeof k.chain_verified==="boolean"?(k.chain_verified?"chain verified":"chain not verified"):"verification unavailable");
-  const observed=s.observed_at||s.observedAt||s.timestamp;
+  document.getElementById("cChainSub").textContent = (k.chain_verified? "chain verified":"unverified");
   kv.innerHTML =
-    row("organ",s.organ)+
-    row("role",s.role)+
-    row("Λ-gate floor",s.lambda_gate_floor)+
-    row("size guard",present(s.size_guard_bytes)?s.size_guard_bytes+" bytes":null)+
-    row("signatures",Array.isArray(s.signatures)?s.signatures.join(", "):s.signatures)+
-    row("last receipt",s.last_receipt_digest,"digest")+
-    row("khipu head",k.head_digest,"digest")+
-    row("chain verified",typeof k.chain_verified==="boolean"?String(k.chain_verified):null)+
-    row("observed at",observed)+
-    '<div><span class="k">status</span><span class="pill '+(state.ready?'green':'yellow')+'">'+esc(state.normalized)+'</span></div>';
+    '<div><span class="k">organ</span><span class="v">'+esc(s.organ||"Immune (Hukulla)")+'</span></div>'+
+    '<div><span class="k">role</span><span class="v">'+esc(s.role||"")+'</span></div>'+
+    '<div><span class="k">Λ-gate floor</span><span class="v">'+esc(s.lambda_gate_floor)+'</span></div>'+
+    '<div><span class="k">size guard</span><span class="v">'+esc(s.size_guard_bytes)+' bytes</span></div>'+
+    '<div><span class="k">signatures</span><span class="v">'+esc((s.signatures||[]).join(", "))+'</span></div>'+
+    '<div><span class="k">last receipt</span><span class="v digest">'+esc(s.last_receipt_digest||"(none yet)")+'</span></div>'+
+    '<div><span class="k">khipu head</span><span class="v digest">'+esc((k.head_digest||"").slice(0,32))+'…</span></div>'+
+    '<div><span class="k">status</span><span class="pill green">'+esc(s.status||"REAL")+'</span></div>';
 }
 
 async function loadGates(){
-  const result = await requestJSON(BASE + "/gates");
+  const g = await getJSON(BASE + "/gates");
   const tb = document.querySelector("#gatesTable tbody");
-  if(!result.ok||!result.data||!Array.isArray(result.data.gates)){tb.innerHTML='<tr><td class="mono" colspan="5">'+esc(requestFailure(result))+'</td></tr>';return;}
-  const g=result.data;
+  if(!g || !g.gates){tb.innerHTML='<tr><td class="mono" colspan="5">unreachable</td></tr>';return;}
   tb.innerHTML = g.gates.map(x=>
     '<tr><td class="mono">'+esc(x.id)+'</td><td>'+esc(x.name)+'</td><td>'+esc(x.label)+'</td><td>'+esc(x.category)+'</td>'+
     '<td><code>'+esc(String(x.sampleInput).slice(0,46))+'</code> → <b>'+esc(x.expectedDecision)+'</b></td></tr>').join("");
 }
 
 async function loadFeed(){
-  const result = await requestJSON(BASE + "/feed?limit=20");
+  const f = await getJSON(BASE + "/feed?limit=20");
   const tb = document.querySelector("#feedTable tbody");
-  if(!result.ok||!result.data||!Array.isArray(result.data.verdicts)){tb.innerHTML='<tr><td class="mono" colspan="5">'+esc(requestFailure(result))+'</td></tr>';return;}
-  const f=result.data;
-  if(!f.verdicts.length){tb.innerHTML='<tr><td class="mono" colspan="5">IDLE — no verdicts buffered (resets on restart)</td></tr>';return;}
+  if(!f || !f.verdicts || !f.verdicts.length){tb.innerHTML='<tr><td class="mono" colspan="5">IDLE — no verdicts buffered (resets on restart)</td></tr>';return;}
   tb.innerHTML = f.verdicts.map(v=>
     '<tr><td>'+esc((v.timestamp||"").slice(11,19))+'</td>'+
     '<td class="'+esc(v.decision)+'">'+esc(v.decision)+'</td>'+
@@ -288,33 +209,21 @@ async function runVerdict(){
   try{ body = JSON.parse(document.getElementById("actionInput").value); }
   catch(e){ out.innerHTML='<div class="verdict-box deny">Invalid JSON: '+esc(e.message)+'</div>'; return; }
   out.innerHTML='<div class="verdict-box">inspecting…</div>';
-  const result = await requestJSON(BASE + "/verdict", {method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(body)});
-  if(!result.ok||!result.data){ out.innerHTML='<div class="verdict-box deny">'+esc(requestFailure(result))+'</div>'; return; }
-  const v=result.data;
-  const decision=String(v.decision||"UNKNOWN").toLowerCase();
-  const cls = decision==="deny"?"deny":decision==="allow"?"allow":"";
-  const pill = decision==="deny"?'<span class="pill red">DENY</span>':decision==="allow"?'<span class="pill green">ALLOW</span>':'<span class="pill yellow">UNKNOWN</span>';
-  const sigs = Array.isArray(v.signals)?(v.signals.map(s=>'<span class="sig">'+esc(s)+'</span>').join("")||'<span class="pill dim">no signals returned</span>'):'<span class="pill dim">signals unavailable</span>';
+  const v = await getJSON(BASE + "/verdict", {method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(body)});
+  if(!v){ out.innerHTML='<div class="verdict-box deny">endpoint unreachable — retry</div>'; return; }
+  const cls = v.decision==="deny"?"deny":"allow";
+  const pill = v.decision==="deny"?'<span class="pill red">DENY</span>':'<span class="pill green">ALLOW</span>';
+  const sigs = (v.signals||[]).map(s=>'<span class="sig">'+esc(s)+'</span>').join("") || '<span class="pill dim">no signal</span>';
   const rec = v.khipu_receipt||{};
-  const observed=v.observed_at||v.observedAt||v.timestamp||rec.observed_at||rec.timestamp;
-  const lambdaEvidence=present(v.lambda_value)?' &nbsp; <span style="color:var(--dim)">Λ='+esc(v.lambda_value)+(present(v.lambda_floor)?' (floor '+esc(v.lambda_floor)+')':'')+'</span>':'';
-  const reasonEvidence=present(v.reason)?'<div style="margin:.4rem 0;color:var(--paragraph)">'+esc(v.reason)+'</div>':'';
-  const policyEvidence=row("fail closed",v.fail_closed)+row("doctrine",v.doctrine);
-  const receiptEvidence=
-    row("verdict hash",v.receipt_hash,"digest")+
-    row("receipt digest",rec.digest,"digest")+
-    row("receipt sequence",rec.seq)+
-    row("receipt type",rec.receipt_type)+
-    row("signature",rec.signature,"digest")+
-    row("chain verified",typeof rec.chain_verified==="boolean"?String(rec.chain_verified):null)+
-    row("traceparent",v.traceparent,"digest")+
-    row("observed at",observed);
   out.innerHTML =
     '<div class="verdict-box '+cls+'">'+
-      '<div>decision '+pill+lambdaEvidence+'</div>'+
-      reasonEvidence+
+      '<div>decision '+pill+' &nbsp; <span style="color:var(--dim)">Λ='+esc(v.lambda_value)+' (floor '+esc(v.lambda_floor)+')</span></div>'+
+      '<div style="margin:.4rem 0;color:var(--paragraph)">'+esc(v.reason)+'</div>'+
       '<div style="margin:.3rem 0;">signals: '+sigs+'</div>'+
-      '<div class="kv">'+receiptEvidence+policyEvidence+'</div>'+
+      '<div><span style="color:var(--dim)">verdict hash</span> <span class="digest">'+esc(v.receipt_hash)+'</span></div>'+
+      '<div><span style="color:var(--dim)">Khipu receipt</span> <span class="digest">'+esc(rec.digest||"")+'</span> '+
+        '<span style="color:var(--dim)">seq '+esc(rec.seq)+' · '+esc(rec.receipt_type||"SZL.Immune.Verdict.v1")+'</span></div>'+
+      '<div style="color:var(--dim);margin-top:.3rem">fail-closed='+esc(v.fail_closed)+' · doctrine '+esc(v.doctrine)+'</div>'+
     '</div>';
   loadStatus(); loadFeed();
 }