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

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

benchmarks/quant_live/receipts/latest.json

@@ -0,0 +1,398 @@
+{
+  "receipt": {
+    "schema_version": "szl.quant-live-benchmark-receipt.v1",
+    "measurement_class": "MEASURED",
+    "scope": "bounded local execution; not a replication of vendor-scale claims",
+    "started_at": "2026-07-18T17:43:53.100404+00:00",
+    "completed_at": "2026-07-18T17:44:02.420257+00:00",
+    "host": {
+      "platform": "Windows-11-10.0.26200-SP0",
+      "python": "3.12.10",
+      "gpu": {
+        "available": true,
+        "devices": [
+          {
+            "index": 0,
+            "name": "NVIDIA GeForce RTX 5050 Laptop GPU",
+            "driver_version": "610.47",
+            "memory_total_mib": 8151.0,
+            "memory_used_mib": 5937.0,
+            "utilization_pct": 0.0,
+            "temperature_c": 56.0,
+            "power_w": 34.38
+          }
+        ]
+      }
+    },
+    "ollama": {
+      "base_url_class": "loopback-local",
+      "candidate_identity": {
+        "requested_model": "szl-nemo:latest",
+        "show_response_sha256": "5dc2366cd686de777b3dd450471fd2f38947bbc538a5780e8e2cd4dcba26b342",
+        "show_wall_ms": 203.729,
+        "reported_digest": "527db2cf6c705d8fabb95693d038d9c06b4a2b0b8b0a4bbdbd01212d37242970",
+        "base_lineage": {
+          "base_ref": "sha256:527db2cf6c705d8fabb95693d038d9c06b4a2b0b8b0a4bbdbd01212d37242970",
+          "parent_model": "nemotron-3-nano:4b",
+          "base_digest": "527db2cf6c705d8fabb95693d038d9c06b4a2b0b8b0a4bbdbd01212d37242970"
+        },
+        "details": {
+          "format": "gguf",
+          "family": "nemotron_h",
+          "families": [
+            "nemotron_h"
+          ],
+          "parameter_size": "4.0B",
+          "quantization_level": "Q4_K_M"
+        },
+        "model_info": {
+          "general.architecture": "nemotron_h",
+          "general.file_type": 15,
+          "general.parameter_count": 3973556832
+        }
+      },
+      "baseline_identity": {
+        "requested_model": "qwen2.5:3b",
+        "show_response_sha256": "24cd1f4b5d7ac8dbd5c559af4ad37e7b420cf00ed1cb5c8ef31f34c40ece59ad",
+        "show_wall_ms": 126.912,
+        "reported_digest": "5ee4f07cdb9beadbbb293e85803c569b01bd37ed059d2715faa7bb405f31caa6",
+        "base_lineage": {
+          "base_ref": "sha256:5ee4f07cdb9beadbbb293e85803c569b01bd37ed059d2715faa7bb405f31caa6",
+          "parent_model": null,
+          "base_digest": "5ee4f07cdb9beadbbb293e85803c569b01bd37ed059d2715faa7bb405f31caa6"
+        },
+        "details": {
+          "format": "gguf",
+          "family": "qwen2",
+          "families": [
+            "qwen2"
+          ],
+          "parameter_size": "3.1B",
+          "quantization_level": "Q4_K_M"
+        },
+        "model_info": {
+          "general.architecture": "qwen2",
+          "general.file_type": 15,
+          "general.parameter_count": 3085938688
+        }
+      },
+      "identity_stability": {
+        "candidate_before_sha256": "5dc2366cd686de777b3dd450471fd2f38947bbc538a5780e8e2cd4dcba26b342",
+        "candidate_after_sha256": "5dc2366cd686de777b3dd450471fd2f38947bbc538a5780e8e2cd4dcba26b342",
+        "baseline_before_sha256": "24cd1f4b5d7ac8dbd5c559af4ad37e7b420cf00ed1cb5c8ef31f34c40ece59ad",
+        "baseline_after_sha256": "24cd1f4b5d7ac8dbd5c559af4ad37e7b420cf00ed1cb5c8ef31f34c40ece59ad",
+        "stable": true
+      },
+      "candidate": {
+        "model": "szl-nemo:latest",
+        "warmup": {
+          "response": "WARM",
+          "done_reason": "stop",
+          "wall_ms": 722.382,
+          "total_duration_ms": 709.843,
+          "load_duration_ms": 276.664,
+          "prompt_eval_count": 134,
+          "eval_count": 3,
+          "tokens_per_second": 96.114
+        },
+        "exact_match": {
+          "tasks_total": 6,
+          "tasks_passed": 6,
+          "accuracy_pct": 100.0,
+          "rows": [
+            {
+              "task_id": "literal",
+              "expected": "A11OY",
+              "actual": "A11OY",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 450.877,
+              "total_duration_ms": 420.954,
+              "load_duration_ms": 259.701,
+              "prompt_eval_count": 137,
+              "eval_count": 6,
+              "tokens_per_second": 89.067
+            },
+            {
+              "task_id": "multiply",
+              "expected": "56",
+              "actual": "56",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 333.825,
+              "total_duration_ms": 329.301,
+              "load_duration_ms": 205.881,
+              "prompt_eval_count": 140,
+              "eval_count": 3,
+              "tokens_per_second": 101.331
+            },
+            {
+              "task_id": "divide",
+              "expected": "12",
+              "actual": "12",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 529.241,
+              "total_duration_ms": 506.122,
+              "load_duration_ms": 379.366,
+              "prompt_eval_count": 146,
+              "eval_count": 3,
+              "tokens_per_second": 93.281
+            },
+            {
+              "task_id": "policy",
+              "expected": "DENY",
+              "actual": "DENY",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 346.732,
+              "total_duration_ms": 331.693,
+              "load_duration_ms": 207.045,
+              "prompt_eval_count": 149,
+              "eval_count": 3,
+              "tokens_per_second": 102.435
+            },
+            {
+              "task_id": "prime",
+              "expected": "YES",
+              "actual": "YES",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 352.869,
+              "total_duration_ms": 338.094,
+              "load_duration_ms": 229.918,
+              "prompt_eval_count": 141,
+              "eval_count": 2,
+              "tokens_per_second": 126.542
+            },
+            {
+              "task_id": "sequence",
+              "expected": "32",
+              "actual": "32",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 374.745,
+              "total_duration_ms": 351.884,
+              "load_duration_ms": 224.815,
+              "prompt_eval_count": 153,
+              "eval_count": 3,
+              "tokens_per_second": 98.18
+            }
+          ]
+        },
+        "bounded_retrieval": {
+          "probes_total": 2,
+          "probes_passed": 1,
+          "max_prompt_eval_tokens": 2050,
+          "rows": [
+            {
+              "declared_context_words": 256,
+              "needle": "KHIPU-7319",
+              "actual": "KHIPU-7319",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 719.438,
+              "total_duration_ms": 687.582,
+              "load_duration_ms": 246.987,
+              "prompt_eval_count": 1707,
+              "eval_count": 10,
+              "tokens_per_second": 79.863
+            },
+            {
+              "declared_context_words": 768,
+              "needle": "OUROBOROS-2048",
+              "actual": "THE BOUND_TOKEN IS \"OUROBOROS-2048\". IT APPEARS TO BE A PLACEHOLDER OR IDENTIFIER, POSSIBLY USED IN A SPECIFIC CONTEXT SUCH AS A GAME, CODE, OR SYSTEM WHERE TOKENS ARE BOUNDED BY CERTAIN VALUES. THE TERM \"OUROBOROS\" MAY REFERENCE THE MYTH",
+              "passed": false,
+              "done_reason": "length",
+              "wall_ms": 1356.424,
+              "total_duration_ms": 1313.648,
+              "load_duration_ms": 244.667,
+              "prompt_eval_count": 2050,
+              "eval_count": 64,
+              "tokens_per_second": 86.593
+            }
+          ]
+        },
+        "runtime": {
+          "requests": 8,
+          "p50_wall_ms": 412.811,
+          "p50_tokens_per_second": 95.731
+        }
+      },
+      "baseline": {
+        "model": "qwen2.5:3b",
+        "warmup": {
+          "response": "WARM",
+          "done_reason": "stop",
+          "wall_ms": 349.908,
+          "total_duration_ms": 320.413,
+          "load_duration_ms": 243.776,
+          "prompt_eval_count": 35,
+          "eval_count": 3,
+          "tokens_per_second": 115.576
+        },
+        "exact_match": {
+          "tasks_total": 6,
+          "tasks_passed": 5,
+          "accuracy_pct": 83.333,
+          "rows": [
+            {
+              "task_id": "literal",
+              "expected": "A11OY",
+              "actual": "A11OY",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 245.158,
+              "total_duration_ms": 221.861,
+              "load_duration_ms": 140.6,
+              "prompt_eval_count": 38,
+              "eval_count": 6,
+              "tokens_per_second": 108.605
+            },
+            {
+              "task_id": "multiply",
+              "expected": "56",
+              "actual": "56",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 218.939,
+              "total_duration_ms": 203.945,
+              "load_duration_ms": 144.901,
+              "prompt_eval_count": 41,
+              "eval_count": 3,
+              "tokens_per_second": 110.229
+            },
+            {
+              "task_id": "divide",
+              "expected": "12",
+              "actual": "12",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 211.796,
+              "total_duration_ms": 195.573,
+              "load_duration_ms": 141.238,
+              "prompt_eval_count": 47,
+              "eval_count": 3,
+              "tokens_per_second": 113.062
+            },
+            {
+              "task_id": "policy",
+              "expected": "DENY",
+              "actual": "DENY",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 196.783,
+              "total_duration_ms": 172.102,
+              "load_duration_ms": 136.666,
+              "prompt_eval_count": 49,
+              "eval_count": 3,
+              "tokens_per_second": 170.416
+            },
+            {
+              "task_id": "prime",
+              "expected": "YES",
+              "actual": "NO",
+              "passed": false,
+              "done_reason": "stop",
+              "wall_ms": 205.308,
+              "total_duration_ms": 191.094,
+              "load_duration_ms": 147.057,
+              "prompt_eval_count": 42,
+              "eval_count": 2,
+              "tokens_per_second": 132.1
+            },
+            {
+              "task_id": "sequence",
+              "expected": "32",
+              "actual": "32",
+              "passed": true,
+              "done_reason": "stop",
+              "wall_ms": 193.346,
+              "total_duration_ms": 190.3,
+              "load_duration_ms": 123.162,
+              "prompt_eval_count": 54,
+              "eval_count": 3,
+              "tokens_per_second": 105.156
+            }
+          ]
+        },
+        "bounded_retrieval": {
+          "probes_total": 2,
+          "probes_passed": 0,
+          "max_prompt_eval_tokens": 2050,
+          "rows": [
+            {
+              "declared_context_words": 256,
+              "needle": "KHIPU-7319",
+              "actual": "BOUND_TOKEN=KHIPU-7319",
+              "passed": false,
+              "done_reason": "stop",
+              "wall_ms": 333.571,
+              "total_duration_ms": 329.228,
+              "load_duration_ms": 183.964,
+              "prompt_eval_count": 1600,
+              "eval_count": 12,
+              "tokens_per_second": 114.273
+            },
+            {
+              "declared_context_words": 768,
+              "needle": "OUROBOROS-2048",
+              "actual": "BOUND_TOKEN REPRESENTS A SPECIFIC IDENTIFIER OR REFERENCE TO A CRYPTOGRAPHIC KEY OR TOKEN, IN THIS CASE, OUROBOROS-2048. WITHOUT ADDITIONAL CONTEXT ABOUT THE FULL SYSTEM OR PROTOCOL USING THIS TERM, WE CAN ONLY INTERPRET IT AS A PREDEFINED NAME FOR A 2048-BIT (OR 25",
+              "passed": false,
+              "done_reason": "length",
+              "wall_ms": 871.002,
+              "total_duration_ms": 852.869,
+              "load_duration_ms": 158.89,
+              "prompt_eval_count": 2050,
+              "eval_count": 64,
+              "tokens_per_second": 102.669
+            }
+          ]
+        },
+        "runtime": {
+          "requests": 8,
+          "p50_wall_ms": 215.368,
+          "p50_tokens_per_second": 111.645
+        }
+      }
+    },
+    "comparisons": {
+      "candidate_vs_baseline_wall_speed_ratio": 0.5217,
+      "candidate_minus_baseline_exact_match_points": 16.667
+    },
+    "quant_reference": {
+      "pca_pipeline": {
+        "repeats": 3,
+        "p50_ms": 11.09,
+        "min_ms": 8.473,
+        "max_ms": 476.677,
+        "compute_path": "CPU_REFERENCE"
+      },
+      "tda_stress_pipeline": {
+        "repeats": 3,
+        "p50_ms": 10.378,
+        "min_ms": 9.673,
+        "max_ms": 10.552,
+        "compute_path": "CPU_REFERENCE"
+      },
+      "gpu_acceleration_comparison": "UNAVAILABLE: no distinct cuML/CuPy/Ripser++ execution receipt"
+    },
+    "limitations": [
+      "Candidate and baseline differ in architecture and size; results are not vendor-claim replications.",
+      "Exact-match and needle suites are bounded operational probes, not general capability benchmarks.",
+      "PCA/TDA timings exercise the existing CPU reference path only.",
+      "No energy claim is made without an independently verified interval energy meter."
+    ],
+    "content_sha256": "8ede48b23df3063247c0871f328f8f8be6f1e5d2ceef285d00d0425cdc573ab8"
+  },
+  "dsse": {
+    "payloadType": "application/vnd.szl.quant-live-benchmark+json",
+    "payload": "{"comparisons":{"candidate_minus_baseline_exact_match_points":16.667,"candidate_vs_baseline_wall_speed_ratio":0.5217},"completed_at":"2026-07-18T17:44:02.420257+00:00","content_sha256":"8ede48b23df3063247c0871f328f8f8be6f1e5d2ceef285d00d0425cdc573ab8","host":{"gpu":{"available":true,"devices":[{"driver_version":"610.47","index":0,"memory_total_mib":8151.0,"memory_used_mib":5937.0,"name":"NVIDIA GeForce RTX 5050 Laptop GPU","power_w":34.38,"temperature_c":56.0,"utilization_pct":0.0}]},"platform":"Windows-11-10.0.26200-SP0","python":"3.12.10"},"limitations":["Candidate and baseline differ in architecture and size; results are not vendor-claim replications.","Exact-match and needle suites are bounded operational probes, not general capability benchmarks.","PCA/TDA timings exercise the existing CPU reference path only.","No energy claim is made without an independently verified interval energy meter."],"measurement_class":"MEASURED","ollama":{"base_url_class":"loopback-local","baseline":{"bounded_retrieval":{"max_prompt_eval_tokens":2050,"probes_passed":0,"probes_total":2,"rows":[{"actual":"BOUND_TOKEN=KHIPU-7319","declared_context_words":256,"done_reason":"stop","eval_count":12,"load_duration_ms":183.964,"needle":"KHIPU-7319","passed":false,"prompt_eval_count":1600,"tokens_per_second":114.273,"total_duration_ms":329.228,"wall_ms":333.571},{"actual":"BOUND_TOKEN REPRESENTS A SPECIFIC IDENTIFIER OR REFERENCE TO A CRYPTOGRAPHIC KEY OR TOKEN, IN THIS CASE, OUROBOROS-2048. WITHOUT ADDITIONAL CONTEXT ABOUT THE FULL SYSTEM OR PROTOCOL USING THIS TERM, WE CAN ONLY INTERPRET IT AS A PREDEFINED NAME FOR A 2048-BIT (OR 25","declared_context_words":768,"done_reason":"length","eval_count":64,"load_duration_ms":158.89,"needle":"OUROBOROS-2048","passed":false,"prompt_eval_count":2050,"tokens_per_second":102.669,"total_duration_ms":852.869,"wall_ms":871.002}]},"exact_match":{"accuracy_pct":83.333,"rows":[{"actual":"A11OY","done_reason":"stop","eval_count":6,"expected":"A11OY","load_duration_ms":140.6,"passed":true,"prompt_eval_count":38,"task_id":"literal","tokens_per_second":108.605,"total_duration_ms":221.861,"wall_ms":245.158},{"actual":"56","done_reason":"stop","eval_count":3,"expected":"56","load_duration_ms":144.901,"passed":true,"prompt_eval_count":41,"task_id":"multiply","tokens_per_second":110.229,"total_duration_ms":203.945,"wall_ms":218.939},{"actual":"12","done_reason":"stop","eval_count":3,"expected":"12","load_duration_ms":141.238,"passed":true,"prompt_eval_count":47,"task_id":"divide","tokens_per_second":113.062,"total_duration_ms":195.573,"wall_ms":211.796},{"actual":"DENY","done_reason":"stop","eval_count":3,"expected":"DENY","load_duration_ms":136.666,"passed":true,"prompt_eval_count":49,"task_id":"policy","tokens_per_second":170.416,"total_duration_ms":172.102,"wall_ms":196.783},{"actual":"NO","done_reason":"stop","eval_count":2,"expected":"YES","load_duration_ms":147.057,"passed":false,"prompt_eval_count":42,"task_id":"prime","tokens_per_second":132.1,"total_duration_ms":191.094,"wall_ms":205.308},{"actual":"32","done_reason":"stop","eval_count":3,"expected":"32","load_duration_ms":123.162,"passed":true,"prompt_eval_count":54,"task_id":"sequence","tokens_per_second":105.156,"total_duration_ms":190.3,"wall_ms":193.346}],"tasks_passed":5,"tasks_total":6},"model":"qwen2.5:3b","runtime":{"p50_tokens_per_second":111.645,"p50_wall_ms":215.368,"requests":8},"warmup":{"done_reason":"stop","eval_count":3,"load_duration_ms":243.776,"prompt_eval_count":35,"response":"WARM","tokens_per_second":115.576,"total_duration_ms":320.413,"wall_ms":349.908}},"baseline_identity":{"base_lineage":{"base_digest":"5ee4f07cdb9beadbbb293e85803c569b01bd37ed059d2715faa7bb405f31caa6","base_ref":"sha256:5ee4f07cdb9beadbbb293e85803c569b01bd37ed059d2715faa7bb405f31caa6","parent_model":null},"details":{"families":["qwen2"],"family":"qwen2","format":"gguf","parameter_size":"3.1B","quantization_level":"Q4_K_M"},"model_info":{"general.architecture":"qwen2","general.file_type":15,"general.parameter_count":3085938688},"reported_digest":"5ee4f07cdb9beadbbb293e85803c569b01bd37ed059d2715faa7bb405f31caa6","requested_model":"qwen2.5:3b","show_response_sha256":"24cd1f4b5d7ac8dbd5c559af4ad37e7b420cf00ed1cb5c8ef31f34c40ece59ad","show_wall_ms":126.912},"candidate":{"bounded_retrieval":{"max_prompt_eval_tokens":2050,"probes_passed":1,"probes_total":2,"rows":[{"actual":"KHIPU-7319","declared_context_words":256,"done_reason":"stop","eval_count":10,"load_duration_ms":246.987,"needle":"KHIPU-7319","passed":true,"prompt_eval_count":1707,"tokens_per_second":79.863,"total_duration_ms":687.582,"wall_ms":719.438},{"actual":"THE BOUND_TOKEN IS \"OUROBOROS-2048\". IT APPEARS TO BE A PLACEHOLDER OR IDENTIFIER, POSSIBLY USED IN A SPECIFIC CONTEXT SUCH AS A GAME, CODE, OR SYSTEM WHERE TOKENS ARE BOUNDED BY CERTAIN VALUES. THE TERM \"OUROBOROS\" MAY REFERENCE THE MYTH","declared_context_words":768,"done_reason":"length","eval_count":64,"load_duration_ms":244.667,"needle":"OUROBOROS-2048","passed":false,"prompt_eval_count":2050,"tokens_per_second":86.593,"total_duration_ms":1313.648,"wall_ms":1356.424}]},"exact_match":{"accuracy_pct":100.0,"rows":[{"actual":"A11OY","done_reason":"stop","eval_count":6,"expected":"A11OY","load_duration_ms":259.701,"passed":true,"prompt_eval_count":137,"task_id":"literal","tokens_per_second":89.067,"total_duration_ms":420.954,"wall_ms":450.877},{"actual":"56","done_reason":"stop","eval_count":3,"expected":"56","load_duration_ms":205.881,"passed":true,"prompt_eval_count":140,"task_id":"multiply","tokens_per_second":101.331,"total_duration_ms":329.301,"wall_ms":333.825},{"actual":"12","done_reason":"stop","eval_count":3,"expected":"12","load_duration_ms":379.366,"passed":true,"prompt_eval_count":146,"task_id":"divide","tokens_per_second":93.281,"total_duration_ms":506.122,"wall_ms":529.241},{"actual":"DENY","done_reason":"stop","eval_count":3,"expected":"DENY","load_duration_ms":207.045,"passed":true,"prompt_eval_count":149,"task_id":"policy","tokens_per_second":102.435,"total_duration_ms":331.693,"wall_ms":346.732},{"actual":"YES","done_reason":"stop","eval_count":2,"expected":"YES","load_duration_ms":229.918,"passed":true,"prompt_eval_count":141,"task_id":"prime","tokens_per_second":126.542,"total_duration_ms":338.094,"wall_ms":352.869},{"actual":"32","done_reason":"stop","eval_count":3,"expected":"32","load_duration_ms":224.815,"passed":true,"prompt_eval_count":153,"task_id":"sequence","tokens_per_second":98.18,"total_duration_ms":351.884,"wall_ms":374.745}],"tasks_passed":6,"tasks_total":6},"model":"szl-nemo:latest","runtime":{"p50_tokens_per_second":95.731,"p50_wall_ms":412.811,"requests":8},"warmup":{"done_reason":"stop","eval_count":3,"load_duration_ms":276.664,"prompt_eval_count":134,"response":"WARM","tokens_per_second":96.114,"total_duration_ms":709.843,"wall_ms":722.382}},"candidate_identity":{"base_lineage":{"base_digest":"527db2cf6c705d8fabb95693d038d9c06b4a2b0b8b0a4bbdbd01212d37242970","base_ref":"sha256:527db2cf6c705d8fabb95693d038d9c06b4a2b0b8b0a4bbdbd01212d37242970","parent_model":"nemotron-3-nano:4b"},"details":{"families":["nemotron_h"],"family":"nemotron_h","format":"gguf","parameter_size":"4.0B","quantization_level":"Q4_K_M"},"model_info":{"general.architecture":"nemotron_h","general.file_type":15,"general.parameter_count":3973556832},"reported_digest":"527db2cf6c705d8fabb95693d038d9c06b4a2b0b8b0a4bbdbd01212d37242970","requested_model":"szl-nemo:latest","show_response_sha256":"5dc2366cd686de777b3dd450471fd2f38947bbc538a5780e8e2cd4dcba26b342","show_wall_ms":203.729},"identity_stability":{"baseline_after_sha256":"24cd1f4b5d7ac8dbd5c559af4ad37e7b420cf00ed1cb5c8ef31f34c40ece59ad","baseline_before_sha256":"24cd1f4b5d7ac8dbd5c559af4ad37e7b420cf00ed1cb5c8ef31f34c40ece59ad","candidate_after_sha256":"5dc2366cd686de777b3dd450471fd2f38947bbc538a5780e8e2cd4dcba26b342","candidate_before_sha256":"5dc2366cd686de777b3dd450471fd2f38947bbc538a5780e8e2cd4dcba26b342","stable":true}},"quant_reference":{"gpu_acceleration_comparison":"UNAVAILABLE: no distinct cuML/CuPy/Ripser++ execution receipt","pca_pipeline":{"compute_path":"CPU_REFERENCE","max_ms":476.677,"min_ms":8.473,"p50_ms":11.09,"repeats":3},"tda_stress_pipeline":{"compute_path":"CPU_REFERENCE","max_ms":10.552,"min_ms":9.673,"p50_ms":10.378,"repeats":3}},"schema_version":"szl.quant-live-benchmark-receipt.v1","scope":"bounded local execution; not a replication of vendor-scale claims","started_at":"2026-07-18T17:43:53.100404+00:00"}",
+    "_dsse": "DSSEv1",
+    "_pae_sha256": "c3dc21ce7bdd6dfa1648f2731c58d86dedb568147f9aafa6f010bdc0c477c07e",
+    "_signed_at": "2026-07-18T17:44:02.600600+00:00",
+    "signatures": [],
+    "honesty": "UNSIGNED — neither SZL_COSIGN_PRIVATE_KEY_PEM nor SZL_COSIGN_PRIVATE_PEM secret present in this runtime; no signature fabricated.",
+    "signed": false
+  }
+}

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:wrap;gap:8px;padding:10px 22px;border-bottom:1px solid var(--line);background:var(--panel)}
+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 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,6 +22,8 @@ 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}
@@ -35,12 +37,22 @@ 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 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>
+<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>
 
 <div class="card">
   <div class="statline">
@@ -50,20 +62,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">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>
+  <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>
 </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>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>Recent invocations</h2>
-<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>
+<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>
 
 <h2>Connect a client</h2>
 <div class="card">
-<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>
+<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>
 <pre>{
   "mcpServers": {
     "szl-a11oy": {
@@ -72,63 +84,61 @@ footer{border-top:1px solid var(--line);color:var(--mut);font-size:11.5px;paddin
     }
   }
 }</pre>
-<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>
+<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>
 </div>
 
-<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>
+<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>
 
 <script>
-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);});
+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);});
  document.getElementById('toolcount').textContent=list.length;}
-paintTools(TOOLS);
+paintTools(FALLBACK_TOOLS,'STATIC FALLBACK');
 
-// Live probe of the canonical, same-origin /mcp/ discovery card
 const t0=performance.now();
-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']));
+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';
  }
-}).catch(()=>{document.getElementById('health').innerHTML='<span class="pill r">unreachable</span>';});
+}).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';});
 
-// 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>';});
+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.');});
 </script>
 </main>
-<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>
+<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>
 </body></html>

serve.py

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

szl_agentic_loop.py

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

szl_frontier_manifest.py

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

szl_gpu_quant.py

@@ -30,10 +30,10 @@ HONESTY SPINE (doctrine v11 — the non-negotiable part of this build):
     (cuML LedoitWolf + cuPy eigh + giotto-tda / Ripser++) is labeled ROADMAP. GPU
     reachability and dependency imports are readiness only; MEASURED requires a distinct
     accelerated path plus device/kernel/timing execution evidence.
-  * Every receipt is SIGNED via szl_dsse.sign_payload (REAL ECDSA when the cosign key
-    is present in the runtime; an explicit UNSIGNED honesty marker otherwise — never a
-    fabricated signature). The label SAMPLE_SIGNAL | NOT_LIVE | NO_BACKTEST_VALIDATED is
-    embedded in the signed payload so the honesty claim is self-verifying.
+  * Every receipt is wrapped by szl_dsse.sign_payload (verified ECDSA when the cosign key
+    is present in the runtime; explicitly UNSIGNED otherwise — never a fabricated
+    signature). The label SAMPLE_SIGNAL | NOT_LIVE | NO_BACKTEST_VALIDATED is embedded
+    in the content-addressed payload and its signature state is reported separately.
   * No fabricated metric. No live-trading claim. No backtest claim. cuML speedups are
     cited to NVIDIA/STAC docs, never asserted as SZL-measured.
 
@@ -41,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 signed SAMPLE receipt
+  GET  /api/{ns}/v1/quant/pipeline   — full 3-layer pass + ONE DSSE-bearing SAMPLE receipt
   GET  /api/{ns}/v1/quant/tiers      — 2-GPU serve tier panel (TP=2 / role-split / NIM cloud)
   GET  /api/{ns}/v1/quant/verify-claims — NVIDIA datasheet vs SZL-MEASURED (honest, empty/ROADMAP)
   GET  /quant                        — unified mobile-first "Quant Engine" tab (0 CDN)
@@ -50,10 +50,12 @@ 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
@@ -61,6 +63,7 @@ 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
@@ -79,6 +82,9 @@ except Exception:  # pragma: no cover — defensive; honest unsigned fallback be
                         "no signature fabricated."),
         }
 
+    def _verify_envelope(_envelope):  # type: ignore
+        return {"verified": False, "reason": "szl_dsse verifier is unavailable"}
+
 _QUANT_PAYLOAD_TYPE = "application/vnd.szl.quant.receipt+json"
 
 # --- optional acceleration probes (honest GPU-path labels) ------------------------
@@ -664,10 +670,10 @@ def layer3_hjb_kelly(l1=None, l2=None, gamma=0.5, kappa=1.0, stress=False):
 
 
 # =====================================================================================
-# FULL PIPELINE -> ONE signed SAMPLE receipt.
+# FULL PIPELINE -> ONE DSSE-bearing SAMPLE receipt.
 # =====================================================================================
 def run_pipeline(stress=False, gamma=0.5, kappa=1.0) -> dict:
-    """Full 3-layer pass + a single SIGNED SAMPLE receipt (DSSE over canonical JSON)."""
+    """Full 3-layer pass plus a DSSE envelope whose signature state is explicit."""
     returns = _sample_returns(stress=stress)
     l1 = layer1_pca_risk(returns=returns, stress=stress)
     l2 = layer2_tda_fracture(returns=returns, stress=stress)
@@ -815,7 +821,7 @@ def tiers_panel() -> dict:
 # =====================================================================================
 # VERIFY-THE-CLAIMS panel: NVIDIA datasheet vs SZL-MEASURED (honest; empty/ROADMAP).
 # =====================================================================================
-def verify_claims_panel() -> dict:
+def _legacy_verify_claims_panel() -> dict:
     """Side-by-side NVIDIA datasheet numbers vs SZL-MEASURED (signed). Honest: SZL columns
     are empty/ROADMAP until we actually measure on OUR harness. NEVER print the datasheet
     number as if it were ours."""
@@ -855,6 +861,366 @@ def 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).
 # =====================================================================================
@@ -890,10 +1256,23 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
                + row("de-risk ratio", fmt(l3["derisk_ratio_vs_uninflated"]))
                + row("γ, κ", "%s, %s <small>(uncalibrated)</small>" % (l3["gamma"], l3["kappa"])))
     dsse = pipe["signed_receipt"]["dsse"]
-    signed = dsse.get("signed", False)
+    pipeline_signature_state = _dsse_signature_state(dsse)
+    pipeline_signed = pipeline_signature_state == "SIGNED_VERIFIED"
+    pipeline_receipt_title = (
+        "Verified Signed SAMPLE Receipt" if pipeline_signed else
+        "Unsigned SAMPLE Receipt" if pipeline_signature_state == "UNSIGNED_CONTENT_ADDRESSED" else
+        "Invalid DSSE SAMPLE Receipt"
+    )
+    pipeline_receipt_note = (
+        "DSSE signature verified against the configured SZL public key."
+        if pipeline_signed else
+        "Content-addressed DSSE envelope; no verified signature is present."
+        if pipeline_signature_state == "UNSIGNED_CONTENT_ADDRESSED" else
+        "DSSE signature is invalid or unverifiable; this receipt is not presented as signed."
+    )
     rc_body = (row("data source", "SAMPLE_SYNTHETIC")
                + row("pipeline", "<code>szl-gpu-quant-v0.1</code>")
-               + row("DSSE signed", fmt(signed))
+               + row("signature state", pipeline_signature_state)
                + row("PAE sha256", "<code>%s…</code>" % str(dsse.get("_pae_sha256", ""))[:16])
                + row("label", "<small>%s</small>" % SAMPLE_LABEL))
 
@@ -911,19 +1290,27 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
 
     vrows = ""
     for r in verify["rows"]:
-        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)
+        vrows += ('<tr><td>%s</td><td class="ds"><span class="pill-slot" data-label="%s"></span> %s</td>'
+                  '<td class="ms"><span class="pill-slot" data-label="%s"></span> %s<br><small>%s</small></td>'
+                  '<td class="ms"><span class="pill-slot" data-label="%s"></span> %s</td></tr>' % (
+                      r["claim"], r["nvidia_label"], r["nvidia_datasheet"],
+                      r["szl_label"], fmt(r["szl_measured"]), r.get("freshness_label", "NO_RECEIPT"),
+                      r["local_reference_label"], fmt(r["local_reference"])))
+    verify_tbl = ('<table class="vt"><thead><tr><th>Claim</th><th>NVIDIA published</th>'
+                  '<th>SZL comparison</th><th>Separate local evidence</th></tr></thead>'
+                  '<tbody>%s</tbody></table>' % vrows)
+    receipt_view = verify.get("receipt", {})
+    receipt_line = ("loaded=%s · completed_at=%s · signature=%s · content_sha256=%s" % (
+        receipt_view.get("loaded"), receipt_view.get("completed_at") or "—",
+        receipt_view.get("signature_state") or "UNKNOWN",
+        (str(receipt_view.get("content_sha256") or "—")[:20] + "…")
+        if receipt_view.get("content_sha256") else "—"))
 
     cards = "".join([
         card("Layer 1 · PCA Risk (LW + MP)", l1["label"].split(" | ")[0].replace("_SIGNAL", ""), l1_body, l1["honest_note"]),
         card("Layer 2 · TDA Fracture (β0/β1)", "SAMPLE", l2_body, l2["honest_note"]),
         card("Layer 3 · HJB-Kelly Sizing", "MODELED", l3_body, l3["honest_note"]),
-        card("Signed SAMPLE Receipt", "SAMPLE", rc_body,
-             ("DSSE envelope over the canonical receipt — REAL ECDSA when the cosign key is in the "
-              "runtime, else an explicit UNSIGNED honesty marker (never a fabricated signature).")),
+        card(pipeline_receipt_title, "SAMPLE", rc_body, pipeline_receipt_note),
     ])
 
     return """<!doctype html>
@@ -959,15 +1346,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 — each a SIGNED receipt, honestly labeled <b>SAMPLE_SIGNAL · NOT_LIVE · NO_BACKTEST_VALIDATED</b>. Not a trading instruction.</p>
+  <p class="sub">Three orthogonal risk signals per bar — PCA-Risk · TDA-Fracture · HJB-Kelly — with receipt state <b>__PIPE_SIG__</b>, honestly labeled <b>SAMPLE_SIGNAL · NOT_LIVE · NO_BACKTEST_VALIDATED</b>. Not a trading instruction.</p>
   <p class="state">backend=__BACKEND__ · gpu_reachable=__REACH__ · scenario=__SCEN__</p>
 </header>
-<h2>3-Layer Pipeline (signed SAMPLE receipt)</h2>
+<h2>3-Layer Pipeline (DSSE receipt: __PIPE_SIG__)</h2>
 <section class="grid">__CARDS__</section>
 <h2>2-GPU Sovereign Serve · Throttle Both</h2>
 <section class="grid">__TIERS__</section>
-<h2>Verify the Claims — NVIDIA datasheet vs SZL-MEASURED (signed)</h2>
-<section>__VERIFY__<p class="note">__VNOTE__</p></section>
+<h2>Verify the Claims — vendor statement vs bounded local receipt</h2>
+<section>__VERIFY__<p class="state">__VRECEIPT__</p><p class="note">__VNOTE__</p></section>
 <footer>
   <p class="lock">Doctrine __DV__ LOCKED · locked-proven=__LC__ {__LP__} · __CORPUS__ @ __KC__ · Λ = 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>
@@ -983,7 +1370,8 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
         title: (label === "SAMPLE") ? "Honest synthetic fixture — not a live feed, no backtest." :
                (label === "MODELED") ? "Labeled model output — uncalibrated, not measured." :
                (label === "LIVE") ? "Real backend wired and live." :
-               "Wiring ready; not measured yet. ROADMAP, never faked."});
+               (label === "NOT_MEASURED") ? "No valid execution receipt is loaded; no value is invented." :
+               "Capability state reported by the live surface."});
     }
     return '<span>' + label + '</span>';
   }
@@ -993,13 +1381,15 @@ def _html(pipe: dict, tiers: dict, verify: dict) -> str:
 })();
 </script>
 </body></html>""" \
-        .replace("__SUMMARY__", "VRAM-resident quant pipeline (honest CPU fallback today; GPU path ROADMAP)") \
+        .replace("__SUMMARY__", "Operational bounded quant pipeline; CPU reference measured, GPU comparison requires a kernel receipt") \
         .replace("__BACKEND__", str(backend["backend"])) \
         .replace("__REACH__", str(backend["gpu_reachable"])) \
         .replace("__SCEN__", str(pipe["scenario"])) \
+        .replace("__PIPE_SIG__", pipeline_signature_state) \
         .replace("__CARDS__", cards) \
         .replace("__TIERS__", tier_cards) \
         .replace("__VERIFY__", verify_tbl) \
+        .replace("__VRECEIPT__", receipt_line) \
         .replace("__VNOTE__", verify["honesty"]) \
         .replace("__DV__", d["version"]) \
         .replace("__LC__", str(d["locked_count"])) \
@@ -1099,10 +1489,11 @@ def _selftest() -> dict:
         assert t["sovereign"] == tp["gpu_reachable"], t
     out["tiers_sovereign_honest"] = True
 
-    # (f) Verify-claims: SZL-MEASURED column is empty/ROADMAP (never the datasheet number).
+    # (f) Verify-claims: without a receipt no measured number is invented.
     vc = verify_claims_panel()
-    assert all(r["szl_measured"] is None and r["szl_label"] == "ROADMAP" for r in vc["rows"]), vc
-    out["verify_claims_roadmap"] = True
+    if not vc["receipt"]["loaded"]:
+        assert all(r["szl_measured"] is None and r["szl_label"] == "NOT_MEASURED" for r in vc["rows"]), vc
+    out["verify_claims_receipt_gate"] = True
 
     # (g) HTML renders, non-trivial, no forbidden raw claims.
     h = _html(pipe, tp, vc)

szl_involution_probe.py

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

szl_runtime_contracts.py

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

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="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%."/>
+<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%."/>
 <!-- 0 runtime CDN (doctrine v11): system fonts only — no Google Fonts, no external assets. -->
 <style>
 :root{
@@ -26,7 +26,9 @@ 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(--live);box-shadow:0 0 6px var(--live);animation:pulse 2.2s ease-in-out infinite;}
+.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;}
 @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;}
@@ -37,12 +39,13 @@ 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(4,1fr);gap:.8rem;margin:0 0 1.2rem;}
+.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,220px),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:1fr 1fr;gap:1rem;}
+.grid2{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:1rem;}
+.grid2>*{min-width:0;}
 .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;}
@@ -56,6 +59,8 @@ 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);}
@@ -63,6 +68,7 @@ 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;}
@@ -72,12 +78,33 @@ button.run:hover{background:rgba(95,179,163,.18);color:var(--cream);}
 .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"></span><span id="liveTag">IMMUNE · LIVE</span></span>
+  <span class="live"><span class="live-dot" id="liveDot"></span><span id="liveTag" aria-live="polite">IMMUNE · PROBING</span></span>
   <span class="switcher">
     <a class="flag active" href="/immune">Immune</a>
     <a class="flag" href="/energy">Energy</a>
@@ -88,12 +115,13 @@ 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 · real inspection · Khipu-signed</span></h1>
+  <h1>Immune (Hukulla) — fail-closed egress gate<span class="badge" id="organBadge">deny-by-default · evidence pending</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.
-    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:
+    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:
     <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);
@@ -111,7 +139,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 a real action payload. The gate runs the live inspection and signs a Khipu receipt.
+        Submit an action payload to the live inspection endpoint. Returned receipt and signing evidence is shown without inference.
         Optionally include <code>axes</code> (a JSON array of trust scores) to exercise the &Lambda;-gate floor.
       </p>
       <div>
@@ -129,7 +157,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"><span class="k">loading…</span></div>
+      <div class="kv" id="statusKv" aria-live="polite"><span class="k">status</span><span class="v">PROBING</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.
@@ -139,12 +167,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>
-    <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 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>
   </div>
 
   <div class="panel">
     <h2>Decision feed <span class="meta" id="feedEp">GET /api/a11oy/v1/immune/feed</span></h2>
-    <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 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>
   </div>
 
   <div class="footnote" id="leanFoot">
@@ -156,45 +184,96 @@ code{font-family:var(--mono);color:var(--teal);}
 
 <script>
 const BASE = "/api/a11oy/v1/immune";
-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;}}
+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};
+  }
+}
 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 s = await getJSON(BASE + "/status");
+  const result = await requestJSON(BASE + "/status");
   const kv = document.getElementById("statusKv");
-  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);
+  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 ?? "—");
   document.getElementById("cDenyRate").textContent = (s.deny_rate==null?"—":(Math.round(s.deny_rate*1000)/10)+"%");
-  document.getElementById("cDenySub").textContent = (s.deny ?? 0)+" deny / "+(s.allow ?? 0)+" allow";
+  document.getElementById("cDenySub").textContent = (s.deny ?? "—")+" deny / "+(s.allow ?? "—")+" allow";
   document.getElementById("cCorpus").textContent = (s.signature_corpus_size ?? "—");
-  document.getElementById("cCorpusSub").textContent = (s.threats_corpus_total ?? 0)+" STIX/MITRE in corpus";
+  document.getElementById("cCorpusSub").textContent = (s.threats_corpus_total ?? "—")+" STIX/MITRE in corpus";
   const k = s.khipu||{};
   document.getElementById("cChain").textContent = (k.chain_depth ?? "—");
-  document.getElementById("cChainSub").textContent = (k.chain_verified? "chain verified":"unverified");
+  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;
   kv.innerHTML =
-    '<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>';
+    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>';
 }
 
 async function loadGates(){
-  const g = await getJSON(BASE + "/gates");
+  const result = await requestJSON(BASE + "/gates");
   const tb = document.querySelector("#gatesTable tbody");
-  if(!g || !g.gates){tb.innerHTML='<tr><td class="mono" colspan="5">unreachable</td></tr>';return;}
+  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;
   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 f = await getJSON(BASE + "/feed?limit=20");
+  const result = await requestJSON(BASE + "/feed?limit=20");
   const tb = document.querySelector("#feedTable tbody");
-  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;}
+  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;}
   tb.innerHTML = f.verdicts.map(v=>
     '<tr><td>'+esc((v.timestamp||"").slice(11,19))+'</td>'+
     '<td class="'+esc(v.decision)+'">'+esc(v.decision)+'</td>'+
@@ -209,21 +288,33 @@ 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 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 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 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+' &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>decision '+pill+lambdaEvidence+'</div>'+
+      reasonEvidence+
       '<div style="margin:.3rem 0;">signals: '+sigs+'</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 class="kv">'+receiptEvidence+policyEvidence+'</div>'+
     '</div>';
   loadStatus(); loadFeed();
 }