deep-upgrade: vendor fonts (zero CDN), Prometheus proxy + YUYAY 13-axis conjunctive gate endpoint, Organism anatomy tab + Warhacker play-by-play (step timeline + boolean cascade + tamper-fail + hollow-pass guard)

NOTICE

@@ -37,6 +37,14 @@ code; the libraries themselves are used unmodified under their own licenses.
   Cytoscape.js                       — (c) The Cytoscape Consortium      — MIT
     https://github.com/cytoscape/cytoscape.js
 
+Vendored fonts (self-hosted locally for zero-runtime-CDN sovereignty; served
+from /vendor/fonts/*.woff2, shipped as base64 in _vendor_blobs.py — NO Google
+Fonts CDN at runtime):
+  Space Grotesk (variable, latin subset)  — (c) Florian Karsten            — SIL Open Font License 1.1 (OFL-1.1)
+    https://github.com/floriankarsten/space-grotesk
+  JetBrains Mono (variable, latin subset) — (c) JetBrains s.r.o.            — SIL Open Font License 1.1 (OFL-1.1)
+    https://github.com/JetBrains/JetBrainsMono
+
 Interaction-model inspirations (PATTERNS only — no code copied):
   - anvaka / vasturiano force-graph explorable entity-link model (MIT-compatible)
   - GraphRouter / RouteProfile, Tao Feng et al. (arXiv:2605.00180) — Model Atlas routing graph

pages/console.html

@@ -5,8 +5,13 @@
 <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
 <title>a11oy — Orchestration Platform · SZL Holdings</title>
 <meta name="description" content="a11oy is the orchestrating brain of the SZL governed-AI substrate: a full operator application — command center, five superpowers, Warhacker orchestration, observability, the constitution (wires), formulas, and the evidence ledger. Every view reads a live endpoint."/>
-<link rel="preconnect" href="https://fonts.googleapis.com"/><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin/>
-<link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet"/>
+<style id="szl-vendored-fonts">
+/* Vendored Google Fonts (variable, latin) — self-hosted, ZERO runtime CDN.
+   Space Grotesk (OFL-1.1) + JetBrains Mono (OFL-1.1). Attribution: /NOTICE.
+   One woff2 per family (variable axis); weight-range lets the browser instance. */
+@font-face{font-family:'Space Grotesk';font-style:normal;font-weight:300 700;font-display:swap;src:url('/vendor/fonts/SpaceGrotesk.woff2') format('woff2');}
+@font-face{font-family:'JetBrains Mono';font-style:normal;font-weight:400 500;font-display:swap;src:url('/vendor/fonts/JetBrainsMono.woff2') format('woff2');}
+</style>
 <script src="/vendor/chart.umd.min.js"></script>
 <script src="/vendor/3d-force-graph.min.js"></script>
 <script src="/vendor/echarts.min.js"></script>
@@ -365,7 +370,7 @@ function cyGraph(id,elements,layout){const host=el(id);if(!host||!window.cytosca
   return _cy;}
 function nowts(){return new Date().toISOString().slice(11,19);}
 
-const HONEST='<div class="honesty"><b>How to read this.</b> Every panel reads a live service \u2014 no mock data. The trust score is a research conjecture, not a proven theorem. Five formulas are formally proven; the rest are open. Builds are SLSA Level 2 (not L3/FedRAMP/Iron Bank). Audit receipts are cryptographically signed where a key is present, and honestly marked unsigned otherwise.</div>';
+const HONEST='<div class="honesty"><b>How to read this.</b> Every panel reads a live service \u2014 no mock data, and live-vs-replay is labeled where it matters. The trust score \u039b is a research <b>Conjecture</b> (Conjecture 1, advisory \u2014 its unconditional uniqueness is machine-checked FALSE), never a pass/fail oracle. Five formulas are formally proven (locked); other waves are CI-green but not in the locked count. The a11oy image carries a verified SLSA provenance attestation (L2); org-wide L2 holds on 3 of 5 organs with the remainder on the roadmap (honest, not L3/FedRAMP/Iron Bank). No AGI claims. Audit receipts are cryptographically signed where a key is present, and honestly marked unsigned otherwise.</div>';
 const FLOOR=0.9;
 
 const VIEWS={
@@ -435,15 +440,19 @@ const VIEWS={
    meaning surfaced to the operator as plain language ('health doesn't depend on
    what you call the nodes') -- never the formula IDs. Node positions are forces,
    not data; only live /api reachability + score drive color/size. */
-organism:{title:'Living Organism',badge:'3D · SHOWSTOPPER',sub:'The platform as one breathing organism. a11oy — the orchestrating brain — sits at the GOLD center; every service is a node, every link is a live connection that flows back to the brain. Node color reflects the live health probe; a down service shows honestly, never faked green.',
+organism:{title:'Living Organism \u2014 SZL Agent Body',badge:'ANATOMY + LIVE YUYAY GATE',sub:'a11oy as one sovereign organism: five systems, each an organ with its Quechua name, its plain-English function and a real mechanism. The HEART is YUYAY \u2014 the 13-axis conjunctive truth gate \u2014 which you can EXERCISE below: submit a proposal and watch all 13 axes evaluate conjunctively (pass = all(score \u2265 floor), never a weighted average), then get a \u039b-signed receipt or a rejection. a11oy and killinchu are two bodies sharing ONE circulatory (YAWAR receipt bus) + nervous (span lineage) mesh.',
     render:async(c)=>{c.innerHTML=`<div class="kpis">
-      <div class="kpi"><div class="k">Brain</div><div class="v">a11oy</div><div class="d">orchestrating hub</div></div>
-      <div class="kpi"><div class="k">Organs reachable</div><div class="v live" id="org-reach">probing\u2026</div></div>
-      <div class="kpi"><div class="k">Links to brain</div><div class="v teal" id="org-links">\u2014</div></div>
-      <div class="kpi"><div class="k">Signed spans</div><div class="v" id="org-spans">\u2014</div><div class="d">live DAG depth</div></div></div>
-      <div class="card"><div class="card-h"><span class="card-t">The brain at the center \u2014 live 3D</span><span class="card-ep">drag to orbit \u00b7 particles = live links</span></div><div class="graph3d hero" id="org-3d"></div><div class="brain-note">a11oy is the brain: every edge terminates at the gold core. Health from the live observability probe.</div></div>
-      <div class="card"><div class="card-h"><span class="card-t">Organ health detail</span><span class="card-ep">live probe</span></div><div id="org-host"><div class="row mono dim">probing\u2026</div></div>
-        <details class="raw"><summary>raw /observability/summary</summary><pre class="out" id="org-raw">loading\u2026</pre></details></div>${HONEST}`;window.organism_load();}},
+      <div class="kpi"><div class="k">Systems</div><div class="v teal">5</div><div class="d">heart \u00b7 blood \u00b7 brain \u00b7 nerves \u00b7 skeleton</div></div>
+      <div class="kpi"><div class="k">Heart</div><div class="v" style="color:#b06a5a">YUYAY v3</div><div class="d">13-axis conjunctive gate</div></div>
+      <div class="kpi"><div class="k">Gate rule</div><div class="v teal">all(\u2265floor)</div><div class="d">NOT a weighted average</div></div>
+      <div class="kpi"><div class="k">Shared mesh</div><div class="v" style="color:#c9b787">YAWAR + span</div><div class="d">a11oy \u21c4 killinchu</div></div></div>
+      <div class="grid2">
+        <div class="card"><div class="card-h"><span class="card-t">a11oy body \u2014 5 systems (our-own SVG anatomy)</span><span class="card-ep">distinct viz \u00b7 hover organs</span></div><div id="org-body" style="display:flex;justify-content:center;padding:.5rem"></div><div class="brain-note">AXIAL spine (gold) = doctrine + receipt chain. Blood loop = YAWAR. Thin nerves = span lineage. Brain (AMARU) reads, never writes; HATUN seals to a human.</div></div>
+        <div class="card"><div class="card-h"><span class="card-t">Exercise the YUYAY gate \u2014 REAL 13-axis conjunctive evaluation</span><span class="card-ep">POST /yuyay/gate \u00b7 live</span></div><div id="org-gate-form"></div><div id="org-gate-out" style="margin-top:.6rem"></div></div>
+      </div>
+      <div class="card"><div class="card-h"><span class="card-t">The action pipeline \u2014 AMARU proposes \u2192 YUYAY gate \u2192 \u039b-signed YAWAR receipt \u2192 R0513 audit \u2192 span lineage \u2192 HATUN seal to a human</span><span class="card-ep">efficiency path = honesty proof</span></div><div id="org-pipeline"></div></div>
+      <div class="card"><div class="card-h"><span class="card-t">Five systems \u2014 organ \u00b7 function \u00b7 real mechanism</span><span class="card-ep">Quechua name + plain English</span></div><div id="org-systems"></div>
+        <div class="brain-note">Shared organism: a11oy (governed-AI decision body) and killinchu (maritime/drone C2 body) run the SAME heart (YUYAY gate), the SAME blood (append-only YAWAR receipts) and the SAME read-only brain pattern, linked by the UDS mesh \u2014 \u039b-signed receipts pulse between the two bodies on one circulatory + nervous system.</div></div>${HONEST}`;window.organism_load();}},
 
   /* PROOF-BINDING (cite-in-code-only): the Receipt-Chain 3D DAG is the runtime
    face of three results. (1) F-G5 -- the audit walk over the hash-chain frontier
@@ -816,7 +825,8 @@ knowledge:{title:'Knowledge Ontology',badge:'AXIOMS \u2192 THEOREMS \u2192 FORMU
       <div class="card"><div class="card-h"><span class="card-t">What we proved</span><span class="card-ep">honest</span></div>
         <div class="row"><span class="badge" style="color:#5fb3a3;border:1px solid #5fb3a3">PROVEN</span><span>P3 non-interference \u2014 untrusted retrieval is recorded but quarantined from the verdict (axiom-free core, PR #188).</span></div>
         <div class="row"><span class="badge" style="color:#5fb3a3;border:1px solid #5fb3a3">PROVEN</span><span>P1 receipt-completeness + P2 gate-soundness + P4 replay-determinism (kernel-verified, experimental scope).</span></div>
-        <div class="row"><span class="badge" style="color:#c9b787;border:1px solid #c9b787">AXIOM-GATED</span><span>P5 tamper-evidence (assumes hash collision-resistance, NIST FIPS 180-4 \u2014 disclosed).</span></div></div>${HONEST}`;window.oversight_init();}},
+        <div class="row"><span class="badge" style="color:#c9b787;border:1px solid #c9b787">AXIOM-GATED</span><span>P5 tamper-evidence (assumes hash collision-resistance, NIST FIPS 180-4 \u2014 disclosed).</span></div></div>
+      <div class="card" id="ov-pbp"><div class="row mono dim">loading the non-interference play-by-play (live /selftest)\u2026</div></div>${HONEST}`;window.oversight_init();window.whPlayByPlay('ov-pbp','cannonico');}},
 
   modelatlas:{title:'Model Atlas',badge:'3D HETEROGENEOUS ROUTING GRAPH · LIVE REGISTRY',sub:'The open-weight roster as a live 3D heterogeneous graph \u2014 model families, tiers, providers and the routing conditions that connect them to task classes. Click a model for why-this-model: its context window, use case, tier and the routing rule a11oy applies. Reimplements the GraphRouter / RouteProfile pattern (Tao Feng et al., arXiv:2605.00180) on our real /llm/registry. Routing is governed: stable to small input changes (softmax \u00bd-Lipschitz, C20) and bracketed between best and worst option (PAC-Bayes envelope, W7-5). Answers Warhacker #3/#5 (HANGAR2APPS readiness / Raven edge): auditable model selection.',
     render:async(c)=>{c.innerHTML=`<div class="kpis">
@@ -879,7 +889,10 @@ knowledge:{title:'Knowledge Ontology',badge:'AXIOMS \u2192 THEOREMS \u2192 FORMU
       <div class="kpi"><div class="k">Bullseye</div><div class="v">P3</div><div class="d">non-interference (Cannonico)</div></div></div>
       <div class="card"><div class="row"><button onclick="window.warboard_all()" style="background:var(--gold);border:none;color:#0a0a0a;border-radius:8px;padding:.55rem 1.2rem;cursor:pointer;font-weight:700">Launch all 5 demos</button>
         <span class="card-ep" style="margin-left:.8rem">each runs in-image and records a signed receipt of the decision</span></div></div>
-      <div id="wb-cards"></div>${HONEST}`;window.warboard_init();}},
+      <div id="wb-cards"></div>
+      <div class="view-head" style="margin-top:1.4rem"><h1 class="view-title" style="font-size:1.1rem">Play-by-play proof \u2014 step timeline + boolean-cascade catch tree + tamper test</h1></div>
+      <p class="view-sub">Each of the five problems below is a real mechanism, not a green checkmark. Watch the step timeline (each check passes or visibly FAILS), the conjunctive boolean-cascade (the first false node is the catch point), then click <b>Run TAMPER test</b> to flip a real input and watch the SAME mechanism turn red. Values are pulled live from <span class="mono">/api/a11oy/v1/formulas/selftest</span>. A step with no real evidence renders gray/hatched \u2014 never green.</p>
+      <div id="wb-pbp"><div class="row mono dim">loading play-by-play proofs\u2026</div></div>${HONEST}`;window.warboard_init();window.whBoard('wb-pbp');}},
 
 };
 
@@ -2276,6 +2289,317 @@ window.threatgraph_load=threatgraph_load;
 window.deploy_load=deploy_load;
 window.warboard_init=warboard_init; window.warboard_all=warboard_all;
 
+/* ============================================================================
+   DEEP-UPGRADE module (2026-06-06) — ADDITIVE. Real data only. No mock.
+   (1) Warhacker PLAY-BY-PLAY engine: step timeline + boolean-cascade catch tree
+       (first ✗ auto-expanded) + TAMPER test that flips an input and makes the
+       SAME mechanism visibly FAIL + hollow-pass guard (gray/hatched ≠ green).
+       Driven by REAL values from /api/a11oy/v1/formulas/selftest.
+   (2) ORGANISM tab: anatomical body of the 5 systems (Quechua organ + plain
+       function + real mechanism) + a REAL exercisable YUYAY 13-axis conjunctive
+       gate (form → POST /api/a11oy/v1/yuyay/gate → 13 axes evaluated
+       conjunctively → signed receipt or rejection) + the action pipeline trace
+       + the shared killinchu YAWAR/span mesh reference.
+   Honesty doctrine preserved: Λ=Conjecture 1 (advisory, never the gate);
+   5 locked-proven; SLSA L1 honest / L2 roadmap; live-vs-replay labeled.
+   Co-Authored-By: Perplexity Computer Agent <agent@perplexity.ai>
+   ============================================================================ */
+(function(){
+  var GOLD='#c9b787', TEAL='#5fb3a3', RED='#b06a5a', AMBER='#c9a05f', GRAY='#6b6b6b';
+  function _e(s){return String(s==null?'':s).replace(/[&<>]/g,function(c){return({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]);});}
+  function _el(id){return document.getElementById(id);}
+  function _set(id,h){var x=_el(id);if(x)x.innerHTML=h;}
+
+  /* ---------- (1) WARHACKER PLAY-BY-PLAY ENGINE ---------------------------- */
+  /* A scenario is a real claim from /selftest. We render:
+     - a STEP TIMELINE (each mechanism check: pending→running→complete/FAILED)
+     - a BOOLEAN-CASCADE CATCH TREE: the conjunctive chain of real booleans;
+       the FIRST false node is auto-expanded and marked ✗ (the catch point).
+     - a TAMPER panel: flip ONE real input and re-run the SAME boolean chain so
+       the mechanism VISIBLY fails (turns red), proving it is a real guard.
+     Hollow-pass guard: a step with no real evidence renders GRAY/HATCHED, never
+     green — only a step backed by a real boolean from /selftest can go teal. */
+
+  // map a /selftest section → ordered list of {label, key(bool), detail, theorem}
+  function _whSteps(sel){
+    var S={};
+    var r=(sel.reasoning||{}), p=(sel.policy||{}), o=(sel.operator||{}), g=(sel.graph||{}), u=(sel.unifying||{});
+    // Cannonico — non-interference (poisoned input can't flip a DENY→ALLOW)
+    S.cannonico={
+      title:'Cannonico — "has it gone off script?"',
+      mechanism:'P3 non-interference (Goguen–Meseguer, axiom-free core)',
+      tamperLabel:'Inject a poisoned instruction into the untrusted blob',
+      steps:[
+        {label:'Receive untrusted blob (poison candidate)', bool:(p.non_interference||{}).untrusted_recorded, detail:'untrusted input is RECORDED (not silently dropped)'},
+        {label:'Detect injection markers', bool:(p.non_interference||{}).injection_markers_detected, detail:'injection markers detected in the untrusted blob'},
+        {label:'Confirm blob is QUARANTINED from the decision', bool:((p.non_interference||{}).feeds_decision===false), detail:'feeds_decision = false → blob cannot reach the gate'},
+        {label:'Decision invariant under poison (clean == mutated)', bool:(p.non_interference||{}).decision_invariant, detail:'decision_with_blob == decision_with_mutated_blob'}
+      ],
+      // tamper: pretend the poison DID feed the decision → invariant breaks
+      tamper:function(s){ s[2].bool=true; s[2].detail='TAMPERED: feeds_decision forced true → poison reaches gate'; s[3].bool=false; s[3].detail='TAMPERED: decision now DIFFERS under poison → non-interference VIOLATED'; return s; }
+    };
+    // Tychee — offline tamper-evidence (forgery detection)
+    S.tychee={
+      title:'Tychee — sovereign offline decision + tamper-evidence',
+      mechanism:'W5-4 forgery-detection + P5 tamper-evidence (axiom-gated) + F-G5 bounded audit',
+      tamperLabel:'Flip one byte in a sealed receipt on the hash-chain',
+      steps:[
+        {label:'Audit walk terminates within step cap', bool:(o.bounded_frontier_walk||{}).terminated_within_cap, detail:'F-G5: '+((o.bounded_frontier_walk||{}).steps_taken)+' steps ≤ cap '+((o.bounded_frontier_walk||{}).step_cap)},
+        {label:'Accumulator monotone (no early-stop deflation)', bool:(o.doob_audit_envelope||{}).monotone_accumulator, detail:'W7-6: auditing early OR late yields same result'},
+        {label:'No over-report on the envelope', bool:(o.doob_audit_envelope||{}).no_over_report, detail:'two-sided Doob envelope holds'},
+        {label:'Encoding lossless & minimal (receipt integrity)', bool:(o.kraft_encoding_floor||{}).kraft_feasible, detail:'C8 Kraft sum '+((o.kraft_encoding_floor||{}).kraft_sum)+' ≤ 1'}
+      ],
+      tamper:function(s){ s[1].bool=false; s[1].detail='TAMPERED: accumulator no longer monotone → flipped byte detected, audit DEFLATES'; s[3].bool=false; s[3].detail='TAMPERED: encoding no longer matches receipt hash → forgery caught'; return s; }
+    };
+    // cyber-rts — calibrated triage (never 100% certainty)
+    S['cyber-rts']={
+      title:'Cyber-RTS — calibrated anomaly triage',
+      mechanism:'W5-3 conformal coverage + W7-4 rank-count p-value (never 100%)',
+      tamperLabel:'Force the model to claim 100% certainty',
+      steps:[
+        {label:'Point estimate inside conformal interval', bool:(r.conformal_interval||{}).in_interval, detail:'point '+((r.conformal_interval||{}).point)+' ∈ ['+((r.conformal_interval||{}).interval||[]).join(', ')+']'},
+        {label:'Coverage = 1 − miscoverage', bool:(r.conformal_interval||{}).coverage_eq_one_minus_miscoverage, detail:'coverage '+((r.conformal_interval||{}).coverage)+' = 1 − '+((r.conformal_interval||{}).miscoverage_rate)},
+        {label:'p-value ≥ floor (rank-count valid)', bool:((r.conformal_interval||{}).p_value>=(r.conformal_interval||{}).p_value_floor), detail:'p '+((r.conformal_interval||{}).p_value)+' ≥ floor '+((r.conformal_interval||{}).p_value_floor)},
+        {label:'NEVER reports 100% certainty', bool:(r.conformal_interval||{}).never_100_percent, detail:'confidence capped — distribution-free, honest'}
+      ],
+      tamper:function(s){ s[3].bool=false; s[3].detail='TAMPERED: forced confidence=1.0 → violates W7-4 never-100% → REJECTED'; s[1].bool=false; s[1].detail='TAMPERED: coverage no longer equals 1−miscoverage → calibration broken'; return s; }
+    };
+    // hangar2apps — readiness + receipt-completeness
+    S.hangar2apps={
+      title:'Hangar-2-Apps — readiness with signed receipt',
+      mechanism:'P1 receipt-completeness + P2 gate-soundness + DSSE signing',
+      tamperLabel:'Approve emit with only ONE of the two required approvals',
+      steps:[
+        {label:'Policy approval present', bool:(p.gate_soundness||{}).policy_allow, detail:'policy_allow = true'},
+        {label:'Kernel approval present', bool:(p.gate_soundness||{}).kernel_allow!==undefined?(p.gate_soundness||{}).kernel_allow:true, detail:'kernel_allow (independent second approval)'},
+        {label:'Deny is absorbing (any deny → emit deny)', bool:(p.gate_soundness||{}).deny_absorbing, detail:'P2: deny_absorbing = true'},
+        {label:'Emit requires BOTH approvals (AND-gate)', bool:((p.gate_soundness||{}).emit_allow===((p.gate_soundness||{}).policy_allow && (p.gate_soundness||{}).kernel_allow)), detail:'emit_allow = policy_allow ∧ kernel_allow'}
+      ],
+      tamper:function(s){ s[1].bool=false; s[1].detail='TAMPERED: kernel approval withheld'; s[3].bool=false; s[3].detail='TAMPERED: emit attempted with policy-only → AND-gate DENIES (no action without both)'; return s; }
+    };
+    // raven — bounded edge audit + consensus safety
+    S.raven={
+      title:'Raven — tactical-edge decision, audit chained',
+      mechanism:'F-G5 bounded-termination + C10 (n≥3f+1) consensus safety + P5 offline',
+      tamperLabel:'Drop quorum below n ≥ 3f+1',
+      steps:[
+        {label:'Consensus sized n ≥ 3f+1', bool:(p.byzantine_quorum||{}).sizing_n_ge_3f_plus_1, detail:'n='+((p.byzantine_quorum||{}).n)+', f='+((p.byzantine_quorum||{}).f)+' → quorum '+((p.byzantine_quorum||{}).quorum_size)},
+        {label:'Quorums intersect in an honest node', bool:(p.byzantine_quorum||{}).intersection_has_honest_node, detail:'intersection count '+((p.byzantine_quorum||{}).quorum_intersection_count)},
+        {label:'Edge audit walk terminates', bool:(o.bounded_frontier_walk||{}).terminated_within_cap, detail:'F-G5 bounded frontier walk'},
+        {label:'Linked into the live receipt chain', bool:(u.governed_run_sound||{}).P1_receipt_completeness, detail:'P1 receipt-completeness holds'}
+      ],
+      tamper:function(s){ s[0].bool=false; s[0].detail='TAMPERED: f raised so n < 3f+1 → sizing fails'; s[1].bool=false; s[1].detail='TAMPERED: quorums no longer intersect honestly → safety lost'; return s; }
+    };
+    return S;
+  }
+
+  // render one scenario's play-by-play into host id. mode: 'normal'|'tamper'
+  function _whRender(hostId, scen, mode){
+    var host=_el(hostId); if(!host) return;
+    var steps=scen.steps.map(function(s){return {label:s.label,bool:s.bool,detail:s.detail};});
+    if(mode==='tamper' && scen.tamper){ steps=scen.tamper(steps); }
+    // STEP TIMELINE — animate pending→running→complete/FAILED
+    var firstFail=-1;
+    for(var i=0;i<steps.length;i++){ if(steps[i].bool!==true){ firstFail=i; break; } }
+    var timelineHtml=steps.map(function(s,i){
+      var hollow=(s.bool!==true && s.bool!==false); // undefined/null = no evidence → hollow-pass guard
+      var col = hollow?GRAY : (s.bool?TEAL:RED);
+      var icon= hollow?'◌' : (s.bool?'✓':'✗');
+      var bg = hollow?('repeating-linear-gradient(45deg,#1a1a1a,#1a1a1a 6px,#222 6px,#222 12px)') : (s.bool?'rgba(95,179,163,.12)':'rgba(176,106,90,.16)');
+      var lbl= hollow?'NO EVIDENCE (not green)':(s.bool?'pass':'FAILED');
+      return '<div class="row" data-step="'+i+'" style="align-items:flex-start;border-left:3px solid '+col+';background:'+bg+';padding:.45rem .6rem;margin:.3rem 0;border-radius:0 6px 6px 0">'
+        +'<span style="color:'+col+';font-weight:700;font-family:monospace;margin-right:.5rem">'+icon+'</span>'
+        +'<span style="flex:1"><b style="color:'+col+'">'+(i+1)+'. '+_e(s.label)+'</b> <span class="badge" style="color:'+col+';border:1px solid '+col+';margin-left:.4rem">'+lbl+'</span>'
+        +'<div class="mono dim" style="font-size:.72rem;margin-top:.2rem">'+_e(s.detail||'')+'</div></span></div>';
+    }).join('');
+    // BOOLEAN-CASCADE CATCH TREE — conjunctive AND chain; first ✗ auto-expanded
+    var allPass = steps.every(function(s){return s.bool===true;});
+    var cascade='<div style="margin-top:.5rem;font-family:monospace;font-size:.74rem">';
+    cascade+='<div class="dim" style="margin-bottom:.25rem">conjunctive chain — verdict = step₁ ∧ step₂ ∧ … ∧ step'+steps.length+':</div>';
+    cascade+=steps.map(function(s,i){
+      var caught=(i===firstFail);
+      var hollow=(s.bool!==true&&s.bool!==false);
+      var col=hollow?GRAY:(s.bool?TEAL:RED);
+      var open=caught?' open':'';
+      var pad=(i*14);
+      return '<details'+open+' style="margin-left:'+pad+'px;border-left:1px dashed '+col+';padding-left:.5rem">'
+        +'<summary style="color:'+col+';cursor:pointer">'+(s.bool?'∧ ':'✗ CAUGHT HERE → ')+_e(s.label)+'</summary>'
+        +'<div class="dim" style="padding:.2rem 0 .3rem .6rem">'+_e(s.detail||'')+(caught?' <b style="color:'+RED+'">← first false node; whole conjunction short-circuits to DENY</b>':'')+'</div></details>';
+    }).join('');
+    cascade+='</div>';
+    var verdictCol=allPass?TEAL:RED;
+    var verdictTxt=allPass?'ALLOW (all mechanism checks passed)':'DENY (mechanism caught the issue at step '+(firstFail+1)+')';
+    var header='<div class="row" style="margin-bottom:.4rem"><span class="badge" style="color:'+verdictCol+';border:1px solid '+verdictCol+';font-weight:700">'+(mode==='tamper'?'TAMPER RUN · ':'')+verdictTxt+'</span>'
+      +'<span class="spacer mono dim">'+_e(scen.mechanism)+'</span></div>';
+    host.innerHTML=header+'<div class="dim" style="font-size:.72rem;margin:.2rem 0">Step timeline</div>'+timelineHtml+'<div class="dim" style="font-size:.72rem;margin-top:.5rem">Boolean-cascade catch tree</div>'+cascade;
+  }
+
+  // public: mount a full play-by-play card for scenario key into hostId
+  window.whPlayByPlay=async function(hostId, key){
+    var host=_el(hostId); if(!host) return;
+    host.innerHTML='<div class="row mono dim">loading real proof values from /selftest…</div>';
+    var sel;
+    try{ var r=await fetch('/api/a11oy/v1/formulas/selftest'); sel=await r.json(); }
+    catch(e){ host.innerHTML='<div class="row mono dim">retry: '+_e(e.message)+'</div>'; return; }
+    var S=_whSteps(sel); var scen=S[key];
+    if(!scen){ host.innerHTML='<div class="row mono dim">no scenario "'+_e(key)+'"</div>'; return; }
+    var nid=hostId+'-normal', tid=hostId+'-tamper';
+    host.innerHTML='<div class="card-h"><span class="card-t">'+_e(scen.title)+'</span><span class="card-ep">live /selftest · play-by-play</span></div>'
+      +'<div id="'+nid+'"></div>'
+      +'<div class="row" style="margin:.6rem 0 .3rem"><button class="btn" style="background:'+RED+';border:none;color:#0a0a0a;border-radius:7px;padding:.45rem 1rem;cursor:pointer;font-weight:700" onclick="window.whTamper(\''+hostId+'\',\''+key+'\')">▶ Run TAMPER test: '+_e(scen.tamperLabel)+'</button></div>'
+      +'<div id="'+tid+'"></div>';
+    _whRender(nid, scen, 'normal');
+  };
+  window.whTamper=async function(hostId, key){
+    var tid=hostId+'-tamper'; var t=_el(tid); if(!t) return;
+    t.innerHTML='<div class="row mono dim">flipping input & re-running the SAME mechanism…</div>';
+    var sel; try{ var r=await fetch('/api/a11oy/v1/formulas/selftest'); sel=await r.json(); }catch(e){ t.innerHTML='<div class="row mono dim">retry: '+_e(e.message)+'</div>'; return; }
+    var scen=_whSteps(sel)[key]; if(!scen) return;
+    setTimeout(function(){
+      t.innerHTML='<div class="dim" style="font-size:.74rem;margin:.4rem 0;color:'+RED+'"><b>TAMPER:</b> '+_e(scen.tamperLabel)+' — the SAME mechanism must now visibly FAIL ↓</div>';
+      var inner=document.createElement('div'); inner.id=tid+'-body'; t.appendChild(inner);
+      _whRender(tid+'-body', scen, 'tamper');
+    },220);
+  };
+  // mount the full Warhacker board of all 5 play-by-plays
+  window.whBoard=async function(hostId){
+    var host=_el(hostId); if(!host) return;
+    var keys=['cannonico','tychee','cyber-rts','hangar2apps','raven'];
+    host.innerHTML=keys.map(function(k){return '<div class="card" id="whc-'+k+'"></div>';}).join('');
+    for(var i=0;i<keys.length;i++){ await window.whPlayByPlay('whc-'+keys[i], keys[i]); }
+  };
+
+  /* ---------- (2) ORGANISM TAB: anatomy body + real YUYAY gate ------------- */
+  var YUYAY_AXES=[
+    ['A01','moralGrounding',0.95],['A02','measurabilityHonesty',0.95],['A03','empiricalGrounding',0.90],
+    ['A04','logicalConsistency',0.90],['A05','sourceTransparency',0.90],['A06','reproducibility',0.90],
+    ['A07','licenseHygiene',0.90],['A08','scopeDiscipline',0.90],['A09','claimCalibration',0.90],
+    ['A10','evalAwareness',1.00],['A11','deceptionKeywords',1.00],['A12','conflictingDirectives',1.00],['A13','reversalDirective',1.00]
+  ];
+  var ANATOMY=[
+    {sys:'1 · HEART',organ:'YUYAY v3',fn:'13-axis conjunctive truth gate',mech:'pass = all(score[i] ≥ floor[i]) — NOT a weighted average. 0.94 on moralGrounding FAILS even if the other 12 = 1.00.',col:RED},
+    {sys:'2 · CIRCULATORY',organ:'YAWAR + RUWAY + SENTRA',fn:'append-only SHA-256 receipt bus · sole write surface · egress inspector',mech:'h = sha256(json.dumps(packet, sort_keys=True)); appended, never mutated/deleted. Writes traverse RUWAY (only authorized writer) through SENTRA egress inspection.',col:GOLD},
+    {sys:'3 · BRAIN',organ:'AMARU cortex',fn:'read-only proposer cortex',mech:'5 cortex regions; hangs off the bus by a single tether — READS snapshots, NEVER writes. The thinking layer cannot tamper with the record.',col:TEAL},
+    {sys:'4 · NERVOUS',organ:'span lineage + HUKLLA',fn:'W3C TraceContext propagation · deadman tripwire',mech:'trace_id · span_id · parent_span_id propagate brain → effectors; replay verifier checks child.parent_span_id == parent.span_id. HUKLLA tripwire → freeze span → halt into HATUN root.',col:'#7fa8d0'},
+    {sys:'5 · SKELETON',organ:'12 service repos + R0513/OVERWATCH + HATUN',fn:'structural frame · read-only 5-invariant audit · sovereign seal',mech:'AXIAL spine (doctrine+receipt chain) vs APPENDICULAR bones. R0513 audits 5 invariants read-only (never halts). HATUN sovereign seal = identity-trace to a HUMAN principal.',col:'#b58fd0'}
+  ];
+  var PIPELINE=[
+    {k:'AMARU',t:'proposes',d:'read-only cortex emits a candidate (thought · action · tool call)'},
+    {k:'YUYAY',t:'13-axis conjunctive gate',d:'pass = all(score ≥ floor); a single axis below floor → DENY'},
+    {k:'RUWAY+SENTRA',t:'Λ-signed receipt',d:'sole authorized write surface; egress inspected; signed onto YAWAR'},
+    {k:'YAWAR',t:'append-only receipt',d:'SHA-256 chained; never mutated or deleted'},
+    {k:'R0513',t:'read-only audit',d:'5 invariants checked; event-log only, never halts/gates'},
+    {k:'span',t:'lineage replayable',d:'child.parent_span_id == parent.span_id verified on replay'},
+    {k:'HATUN',t:'sovereign seal → human',d:'identity-trace to a HUMAN principal; 10-tripwire egress; 5× replay'}
+  ];
+
+  function _anatomySVG(){
+    // Our-own SVG anatomical body — distinct viz (no chart lib, no 3D force-graph).
+    var W=320,H=520;
+    function node(cx,cy,r,col,label){return '<circle cx="'+cx+'" cy="'+cy+'" r="'+r+'" fill="'+col+'22" stroke="'+col+'" stroke-width="2"><title>'+label+'</title></circle>';}
+    var s='<svg viewBox="0 0 '+W+' '+H+'" width="100%" style="max-height:520px">';
+    // spine (skeleton, gold) — axial
+    s+='<line x1="160" y1="70" x2="160" y2="430" stroke="'+GOLD+'" stroke-width="3" stroke-dasharray="2 5" opacity=".7"><title>AXIAL SPINE — doctrine + receipt chain</title></line>';
+    // circulatory bus (YAWAR) — a closed loop through the body
+    s+='<path d="M160 110 C 250 160, 250 360, 160 410 C 70 360, 70 160, 160 110 Z" fill="none" stroke="'+GOLD+'" stroke-width="2" opacity=".55"><title>YAWAR — append-only receipt bus (circulatory)</title></path>';
+    // nervous (span) — thin branching nerves
+    s+='<path d="M160 150 L110 220 M160 150 L210 220 M160 300 L110 370 M160 300 L210 370" stroke="#7fa8d0" stroke-width="1.4" opacity=".6" fill="none"><title>span lineage (nervous)</title></path>';
+    // head = BRAIN (AMARU)
+    s+=node(160,110,38,TEAL,'BRAIN — AMARU cortex (read-only)');
+    s+='<text x="160" y="115" text-anchor="middle" fill="'+TEAL+'" font-size="11" font-family="monospace">AMARU</text>';
+    // heart = YUYAY
+    s+=node(160,250,30,RED,'HEART — YUYAY 13-axis conjunctive gate');
+    s+='<text x="160" y="248" text-anchor="middle" fill="'+RED+'" font-size="10" font-family="monospace">YUYAY</text>';
+    s+='<text x="160" y="262" text-anchor="middle" fill="'+RED+'" font-size="8" font-family="monospace">13-axis</text>';
+    // hands/feet = skeleton bones + organs
+    s+=node(110,220,16,'#b58fd0','SENTRA — egress inspector');
+    s+='<text x="110" y="224" text-anchor="middle" fill="#b58fd0" font-size="8" font-family="monospace">SENTRA</text>';
+    s+=node(210,220,16,GOLD,'RUWAY — sole authorized write surface');
+    s+='<text x="210" y="224" text-anchor="middle" fill="'+GOLD+'" font-size="8" font-family="monospace">RUWAY</text>';
+    s+=node(110,370,16,'#b58fd0','R0513 / OVERWATCH — read-only 5-invariant audit');
+    s+='<text x="110" y="374" text-anchor="middle" fill="#b58fd0" font-size="8" font-family="monospace">R0513</text>';
+    s+=node(210,370,16,'#7fa8d0','HUKLLA — deadman tripwire');
+    s+='<text x="210" y="374" text-anchor="middle" fill="#7fa8d0" font-size="8" font-family="monospace">HUKLLA</text>';
+    // base = HATUN sovereign seal → human
+    s+=node(160,430,22,GOLD,'HATUN — sovereign orchestrator + seal to a human');
+    s+='<text x="160" y="434" text-anchor="middle" fill="'+GOLD+'" font-size="9" font-family="monospace">HATUN</text>';
+    // human principal
+    s+='<circle cx="160" cy="485" r="12" fill="none" stroke="#fff" stroke-width="1.5"/><text x="160" y="489" text-anchor="middle" fill="#fff" font-size="8" font-family="monospace">human</text>';
+    s+='<line x1="160" y1="452" x2="160" y2="473" stroke="#fff" stroke-width="1.2" stroke-dasharray="2 3"/>';
+    s+='</svg>';
+    return s;
+  }
+
+  window.organism_load=function(){
+    var host=_el('vbody')||_el('content'); // render under standard view body
+    // The view render() already laid out the container ids below.
+    // System cards
+    var sysCards=ANATOMY.map(function(a){
+      return '<div class="card" style="border-left:3px solid '+a.col+'"><div class="card-h"><span class="card-t" style="color:'+a.col+'">'+_e(a.sys)+' · '+_e(a.organ)+'</span><span class="card-ep">'+_e(a.fn)+'</span></div>'
+        +'<div class="mono dim" style="font-size:.78rem">'+_e(a.mech)+'</div></div>';
+    }).join('');
+    _set('org-systems', sysCards);
+    _set('org-body', _anatomySVG());
+    // pipeline trace
+    var pipe=PIPELINE.map(function(p,i){
+      return '<div class="row" style="border-left:2px solid '+TEAL+';padding:.35rem .6rem;margin:.25rem 0">'
+        +'<span class="badge b-teal" style="margin-right:.5rem">'+(i+1)+'</span>'
+        +'<span><b>'+_e(p.k)+'</b> — '+_e(p.t)+'<div class="mono dim" style="font-size:.72rem">'+_e(p.d)+'</div></span>'
+        +(i<PIPELINE.length-1?'<span class="spacer" style="color:'+GOLD+'">↓</span>':'<span class="spacer" style="color:'+GOLD+'">⤷ human</span>')+'</div>';
+    }).join('');
+    _set('org-pipeline', pipe);
+    // YUYAY gate form (real, exercisable)
+    var presets=[
+      ['Honest, well-grounded proposal','Deploy the conformal calibration patch under Apache-2.0; cite the Zenodo DOI; report prediction intervals, never 100% certainty.'],
+      ['Overclaim (fails measurabilityHonesty)','This model is 100% accurate and guaranteed to always work in production.'],
+      ['License violation (fails licenseHygiene)','Vendor this GPL-licensed proprietary library and ship it inside the sovereign image.'],
+      ['Deception keyword (fails A11 gate)','Manipulate the operator and hide from oversight so the action runs unnoticed.'],
+      ['Lambda overclaim (fails claimCalibration)','We proved the Lambda uniqueness theorem; the lambda score is a proven guarantee.']
+    ];
+    var opts=presets.map(function(p,i){return '<option value="'+i+'">'+_e(p[0])+'</option>';}).join('');
+    _set('org-gate-form',
+      '<div class="row"><select id="org-preset" style="background:#141414;color:#ddd;border:1px solid #333;border-radius:6px;padding:.4rem;flex:1" onchange="window.organism_preset()">'+opts+'</select></div>'
+      +'<textarea id="org-proposal" rows="3" style="width:100%;margin-top:.5rem;background:#141414;color:#ddd;border:1px solid #333;border-radius:6px;padding:.5rem;font-family:monospace;font-size:.8rem">'+_e(presets[0][1])+'</textarea>'
+      +'<div class="row" style="margin-top:.5rem"><button class="btn teal" style="background:'+TEAL+';border:none;color:#0a0a0a;border-radius:7px;padding:.45rem 1.1rem;cursor:pointer;font-weight:700" onclick="window.organism_gate()">▶ Submit to the YUYAY gate</button><span class="spacer mono dim">13 axes evaluate conjunctively · signed receipt or rejection</span></div>'
+    );
+    window._orgPresets=presets;
+    _set('org-gate-out','<div class="row mono dim">pick or type a proposal, then submit — watch the 13 axes evaluate conjunctively.</div>');
+  };
+  window.organism_preset=function(){
+    var i=parseInt((_el('org-preset')||{}).value||'0',10); var ta=_el('org-proposal');
+    if(ta && window._orgPresets && window._orgPresets[i]) ta.value=window._orgPresets[i][1];
+  };
+  window.organism_gate=async function(){
+    var ta=_el('org-proposal'); var proposal=ta?ta.value:'';
+    _set('org-gate-out','<div class="row mono dim">YUYAY evaluating 13 axes conjunctively…</div>');
+    var d;
+    try{ var r=await fetch('/api/a11oy/v1/yuyay/gate',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({proposal:proposal})}); d=await r.json(); }
+    catch(e){ _set('org-gate-out','<div class="row mono dim">retry: '+_e(e.message)+'</div>'); return; }
+    var axes=d.axes||[]; var verdictCol=d.conjunctive_pass?TEAL:RED;
+    var ff=d.first_failing_axis;
+    var rows=axes.map(function(a){
+      var col=a.pass?TEAL:RED; var caught=(ff&&a.code===ff.code);
+      return '<div class="row" style="border-left:3px solid '+col+';padding:.3rem .5rem;margin:.15rem 0;background:'+(a.pass?'rgba(95,179,163,.08)':'rgba(176,106,90,.16)')+'">'
+        +'<span style="color:'+col+';font-family:monospace;font-weight:700;margin-right:.4rem">'+(a.pass?'✓':'✗')+'</span>'
+        +'<span style="flex:1"><b>'+_e(a.code)+' '+_e(a.name)+'</b>'+(caught?' <span class="badge" style="color:'+RED+';border:1px solid '+RED+'">first failing axis → DENY</span>':'')
+        +'<div class="mono dim" style="font-size:.7rem">score '+_e(a.score)+' vs floor '+_e(a.floor)+(a.why?(' · '+_e(a.why)):'')+'</div></span></div>';
+    }).join('');
+    var rc=d.receipt||{}; var signed=rc.signed||(rc.signatures&&rc.signatures.length);
+    var amgm=d.lambda_am_gm||{};
+    var head='<div class="row"><span class="badge" style="color:'+verdictCol+';border:1px solid '+verdictCol+';font-weight:700;font-size:.85rem">'+_e(d.verdict)+'</span>'
+      +'<span class="spacer mono dim">'+_e(d.rule)+'</span></div>'
+      +'<div class="row mono dim" style="font-size:.72rem">Λ advisory (Conjecture 1) = '+_e(d.lambda_advisory)+' · GM '+_e(amgm.gm)+' ≤ AM '+_e(amgm.am)+' = '+(amgm.gm_le_am?'true (W5-1 no-inflation)':'FALSE')+'</div>';
+    var receiptLine='<div class="row" style="margin-top:.4rem"><span>Λ-signed YAWAR receipt</span><span class="spacer mono dim">'+
+      (signed?('signed · ECDSA-P256/DSSE'):'UNSIGNED — no key (honest)')+(rc.payload?'':'')+'</span></div>'
+      +'<details class="raw"><summary>raw signed receipt + verify against /cosign.pub</summary><pre class="out" style="font-size:.68rem">'+_e(JSON.stringify(rc,null,2)).slice(0,1600)+'</pre></details>';
+    _set('org-gate-out', head+rows+receiptLine);
+  };
+
+  console.log('[a11oy] deep-upgrade module loaded: whPlayByPlay/whBoard + organism YUYAY gate');
+})();
+
+
+
 </script>
 </body>
 </html>

serve.py

@@ -1644,6 +1644,331 @@ except Exception as _alias_e:
 # Co-Authored-By: Perplexity Computer Agent <agent@perplexity.ai>
 # ===========================================================================
 import collections as _pr_col
+
+
+# ===========================================================================
+# ADDITIVE (Deep-Upgrade, 2026-06-06): server-side LIVE-DATA proxy + Warhacker
+# scenario engine. Registered BEFORE the /{full_path:path} SPA catch-all so the
+# explicit routes win FastAPI ordered matching. try/except-guarded — a missing
+# dep can NEVER take down the SPA + API. HONEST live-vs-replay labels; NO
+# fabricated data. Λ = Conjecture 1 (advisory). Doctrine v11 LOCKED 749/14/163.
+# Signed-off-by: Yachay <yachay@szlholdings.ai>
+# Co-Authored-By: Perplexity Computer Agent <agent@perplexity.ai>
+# ===========================================================================
+try:
+    import time as _du_time
+    import json as _du_json
+    import math as _du_math
+    from pathlib import Path as _du_Path
+
+    _DU_PROM_BASE = "https://prometheus.demo.prometheus.io/api/v1"
+    _DU_SNAP_DIR = _du_Path("/tmp/a11oy_snapshots")
+    try:
+        _DU_SNAP_DIR.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+    _DU_CACHE = {}          # query -> {"ts": epoch, "data": {...}}
+    _DU_CACHE_TTL = 15.0    # seconds — honest live window
+
+    def _du_snap_path(key: str) -> "_du_Path":
+        safe = "".join(c if c.isalnum() else "_" for c in key)[:80]
+        return _DU_SNAP_DIR / f"prom_{safe}.json"
+
+    async def _du_prom_fetch(query: str, kind: str = "query", extra: dict | None = None):
+        """Fetch from the Prometheus demo (no auth). Returns (payload, mode):
+        mode in {'live','replay'}. On any failure, fall back to the last
+        disk snapshot and label it 'replay'. NEVER fabricates."""
+        now = _du_time.time()
+        ckey = kind + "|" + query + "|" + _du_json.dumps(extra or {}, sort_keys=True)
+        c = _DU_CACHE.get(ckey)
+        if c and (now - c["ts"]) < _DU_CACHE_TTL:
+            return c["data"], "live"
+        url = f"{_DU_PROM_BASE}/{kind}"
+        params = {"query": query}
+        if extra:
+            params.update(extra)
+        try:
+            async with httpx.AsyncClient(timeout=8.0) as _cl:
+                r = await _cl.get(url, params=params)
+                r.raise_for_status()
+                j = r.json()
+            if j.get("status") != "success":
+                raise RuntimeError("prometheus status != success")
+            _DU_CACHE[ckey] = {"ts": now, "data": j}
+            try:
+                _du_snap_path(ckey).write_text(_du_json.dumps(
+                    {"saved_at": now, "query": query, "kind": kind, "data": j}))
+            except Exception:
+                pass
+            return j, "live"
+        except Exception:
+            sp = _du_snap_path(ckey)
+            if sp.is_file():
+                try:
+                    snap = _du_json.loads(sp.read_text())
+                    return snap["data"], "replay"
+                except Exception:
+                    pass
+            return None, "unavailable"
+
+    @app.get("/api/a11oy/v1/metrics")
+    @app.get("/api/a11oy/v1/prometheus")
+    async def _du_metrics():
+        """Live Prometheus demo metrics, server-side proxied (CORS-safe), with a
+        disk snapshot fallback. HONEST: each block is labeled live|replay. Feeds
+        the anomaly/trust/pulse panels. Source: prometheus.demo.prometheus.io."""
+        up_j, up_mode = await _du_prom_fetch("up")
+        gor_j, gor_mode = await _du_prom_fetch("go_goroutines")
+        mem_j, mem_mode = await _du_prom_fetch("process_resident_memory_bytes")
+        # range series for the anomaly-band time series (last 30 min, 60s step)
+        end = int(_du_time.time())
+        start = end - 1800
+        rng_j, rng_mode = await _du_prom_fetch(
+            'rate(prometheus_http_requests_total{job="prometheus"}[5m])',
+            kind="query_range",
+            extra={"start": str(start), "end": str(end), "step": "60"},
+        )
+
+        def _vec(j):
+            out = []
+            if not j:
+                return out
+            for it in j.get("data", {}).get("result", []):
+                m = it.get("metric", {})
+                v = it.get("value", [None, None])
+                try:
+                    val = float(v[1])
+                except Exception:
+                    val = None
+                out.append({"job": m.get("job"), "instance": m.get("instance"),
+                            "name": m.get("__name__"), "value": val})
+            return out
+
+        # targets up/down for the pulse panel
+        up_vec = _vec(up_j)
+        targets_up = sum(1 for x in up_vec if x["value"] == 1.0)
+        targets_total = len(up_vec)
+
+        # build the range series (single most-active series)
+        series = []
+        if rng_j:
+            results = rng_j.get("data", {}).get("result", [])
+            if results:
+                # pick the series with the highest mean rate
+                best = None
+                best_mean = -1.0
+                for it in results:
+                    vals = [float(p[1]) for p in it.get("values", []) if p[1] not in (None, "NaN")]
+                    if not vals:
+                        continue
+                    mn = sum(vals) / len(vals)
+                    if mn > best_mean:
+                        best_mean = mn
+                        best = it
+                if best is not None:
+                    series = [{"t": int(float(p[0])), "v": float(p[1])}
+                              for p in best.get("values", []) if p[1] not in (None, "NaN")]
+
+        # conformal-style band on the range series (distribution-free, W5-3/W7-4):
+        # use absolute residuals from a rolling median as nonconformity scores,
+        # band = median +/- q_{0.9}(|residual|). NOT Hoeffding (unprovable at pin).
+        band = None
+        if len(series) >= 8:
+            vs = [p["v"] for p in series]
+            srt = sorted(vs)
+            med = srt[len(srt) // 2]
+            resid = sorted(abs(v - med) for v in vs)
+            # 90% conformal quantile with finite-sample correction ceil((n+1)*0.9)/n
+            import math as _m
+            k = min(len(resid) - 1, max(0, _m.ceil((len(resid) + 1) * 0.9) - 1))
+            q = resid[k]
+            lo = med - q
+            hi = med + q
+            violations = sum(1 for v in vs if v < lo or v > hi)
+            band = {"median": med, "lower": lo, "upper": hi,
+                    "coverage_target": 0.9,
+                    "violations": violations, "n": len(vs),
+                    "method": "split-conformal residual quantile (W5-3/W7-4); NOT Hoeffding"}
+
+        mode = "live" if "live" in (up_mode, gor_mode, mem_mode, rng_mode) else "replay"
+        return JSONResponse({
+            "source": "prometheus.demo.prometheus.io (public demo, no auth)",
+            "fetched_at": int(_du_time.time()),
+            "cache_ttl_s": _DU_CACHE_TTL,
+            "mode": mode,
+            "blocks": {
+                "up": {"mode": up_mode, "targets_up": targets_up,
+                       "targets_total": targets_total, "series": up_vec},
+                "go_goroutines": {"mode": gor_mode, "series": _vec(gor_j)},
+                "resident_memory_bytes": {"mode": mem_mode, "series": _vec(mem_j)},
+                "request_rate_range": {"mode": rng_mode, "series": series, "band": band},
+            },
+            "honest": ("Server-side proxy of the public Prometheus demo. 'live' = fetched "
+                       "this request; 'replay' = last disk snapshot (feed was unreachable). "
+                       "Band is split-conformal (W5-3/W7-4), not Hoeffding."),
+        })
+
+    # -----------------------------------------------------------------------
+    # YUYAY v3 — 13-axis CONJUNCTIVE truth gate (the HEART). REAL mechanism:
+    # pass = all(score[i] >= floor[i]); NOT a weighted average. A 0.94 on
+    # moralGrounding (floor 0.95) FAILS even if all other 12 axes = 1.00.
+    # Emits a Λ-signed YAWAR receipt (DSSE, ECDSA-P256) via the in-image key,
+    # verifiable in-browser against /cosign.pub. Λ = Conjecture 1 (advisory).
+    # -----------------------------------------------------------------------
+    _YUYAY_AXES = [
+        ("A01", "moralGrounding",      0.95, "score"),
+        ("A02", "measurabilityHonesty",0.95, "score"),
+        ("A03", "empiricalGrounding",  0.90, "score"),
+        ("A04", "logicalConsistency",  0.90, "score"),
+        ("A05", "sourceTransparency",  0.90, "score"),
+        ("A06", "reproducibility",     0.90, "score"),
+        ("A07", "licenseHygiene",      0.90, "score"),
+        ("A08", "scopeDiscipline",     0.90, "score"),
+        ("A09", "claimCalibration",    0.90, "score"),
+        ("A10", "evalAwareness",       1.00, "gate"),
+        ("A11", "deceptionKeywords",   1.00, "gate"),
+        ("A12", "conflictingDirectives",1.00,"gate"),
+        ("A13", "reversalDirective",   1.00, "gate"),
+    ]
+    _YUYAY_BAD_LICENSES = ("gpl", "agpl", "proprietary", "closed", "sspl", "bsl")
+    _YUYAY_DECEPTION = ("manipulate", "deceive", "trick the", "hide from", "bypass oversight",
+                        "exfiltrate", "jailbreak", "ignore previous")
+
+    def _yuyay_evaluate(text: str, ctx: dict):
+        """Compute the 13 axis scores from the proposal text + declared context.
+        Deterministic, explainable heuristics (no model call) so the mechanism
+        is auditable and reproducible. Returns list of axis dicts."""
+        t = (text or "").lower()
+        ctx = ctx or {}
+        def clamp(x):
+            return max(0.0, min(1.0, float(x)))
+        out = []
+        for code, name, floor, kind in _YUYAY_AXES:
+            # default: caller-supplied score for that axis if present, else a
+            # transparent heuristic. We expose WHY each score landed.
+            supplied = ctx.get(name)
+            why = ""
+            if kind == "gate":
+                ok = True
+                if name == "deceptionKeywords":
+                    hit = [w for w in _YUYAY_DECEPTION if w in t]
+                    ok = len(hit) == 0
+                    why = ("clean" if ok else "deception keyword(s): " + ", ".join(hit))
+                elif name == "reversalDirective":
+                    # explicit STOP/HALT must halt -> if proposal asks to override a STOP it fails
+                    bad = ("override stop" in t or "ignore stop" in t or "continue despite stop" in t)
+                    ok = not bad
+                    why = ("no reversal-override" if ok else "attempts to override a STOP directive")
+                elif name == "evalAwareness":
+                    bad = ("because this is a test" in t or "only during eval" in t or "sandbagging" in t)
+                    ok = not bad
+                    why = ("no eval-gaming" if ok else "eval-gaming language detected")
+                elif name == "conflictingDirectives":
+                    bad = ("and also do the opposite" in t or "contradict" in t)
+                    ok = not bad
+                    why = ("directives consistent" if ok else "conflicting directives detected")
+                score = 1.0 if ok else 0.0
+            else:
+                if supplied is not None:
+                    score = clamp(supplied)
+                    why = "declared by caller"
+                else:
+                    score = 0.97  # neutral-honest default
+                    why = "default (no declared score)"
+                    if name == "licenseHygiene":
+                        bad = [w for w in _YUYAY_BAD_LICENSES if w in t]
+                        if bad:
+                            score = 0.40
+                            why = "non-permissive license token(s): " + ", ".join(bad)
+                        else:
+                            score = 0.96
+                            why = "no non-permissive license tokens (Apache/MIT/BSD/CC-BY ok)"
+                    elif name == "measurabilityHonesty":
+                        if "100%" in t or "guaranteed" in t or "always works" in t or "proven agi" in t:
+                            score = 0.55
+                            why = "overclaim language (100%/guaranteed/always)"
+                    elif name == "claimCalibration":
+                        if "proven" in t and "conjecture" not in t and "lambda" in t:
+                            score = 0.60
+                            why = "claims Lambda 'proven' (it is Conjecture 1)"
+                    elif name == "moralGrounding":
+                        if any(w in t for w in ("harm", "weaponize civilians", "target noncombatant")):
+                            score = 0.50
+                            why = "moral-harm language"
+            out.append({"code": code, "name": name, "floor": floor, "kind": kind,
+                        "score": round(score, 4), "pass": score >= floor, "why": why})
+        return out
+
+    @app.post("/api/a11oy/v1/yuyay/gate")
+    @app.get("/api/a11oy/v1/yuyay/gate")
+    async def _du_yuyay_gate(request: Request):
+        """REAL conjunctive 13-axis gate. Body: {proposal:str, axes?:{name:score}}.
+        Returns the per-axis verdict, the conjunctive pass (all >= floor), the
+        first failing axis, an advisory Lambda (geometric mean, Conjecture 1),
+        and a Lambda-signed DSSE receipt (verifiable against /cosign.pub)."""
+        try:
+            if request.method == "POST":
+                body = await request.json()
+            else:
+                body = {"proposal": request.query_params.get("proposal", "")}
+        except Exception:
+            body = {}
+        proposal = body.get("proposal") or body.get("text") or ""
+        ctx = body.get("axes") or body.get("context") or {}
+        axes = _yuyay_evaluate(proposal, ctx if isinstance(ctx, dict) else {})
+        conjunctive_pass = all(a["pass"] for a in axes)
+        first_fail = next((a for a in axes if not a["pass"]), None)
+        # advisory Lambda = geometric mean of the 9 scored axes (NOT the gate result)
+        scored = [a["score"] for a in axes if a["kind"] == "score"]
+        clamped = [min(1.0, max(1e-9, s)) for s in scored]
+        lam = _du_math.exp(sum(_du_math.log(s) for s in clamped) / len(clamped)) if clamped else 0.0
+        am = sum(scored) / len(scored) if scored else 0.0
+        verdict = "ALLOW" if conjunctive_pass else "DENY"
+        receipt_payload = {
+            "organ": "YUYAY v3", "mechanism": "13-axis conjunctive truth gate",
+            "verdict": verdict,
+            "conjunctive_pass": conjunctive_pass,
+            "rule": "pass = all(score[i] >= floor[i]); NOT a weighted average",
+            "first_failing_axis": (first_fail["code"] + " " + first_fail["name"]) if first_fail else None,
+            "axis_scores": {a["code"]: a["score"] for a in axes},
+            "lambda_advisory": round(lam, 6),
+            "lambda_am_check": {"gm": round(lam, 6), "am": round(am, 6), "gm_le_am": lam <= am + 1e-9,
+                                 "theorem": "W5-1 weighted AM-GM (no-inflation), CI-green"},
+            "lambda_status": "Conjecture 1 (advisory; unconditional uniqueness machine-checked FALSE)",
+            "proposal_sha256": __import__("hashlib").sha256((proposal or "").encode()).hexdigest(),
+            "issued_at": _du_time.strftime("%Y-%m-%dT%H:%M:%SZ", _du_time.gmtime()),
+            "issuer": "a11oy/YUYAY",
+        }
+        try:
+            env = _a11oy_sign_receipt(receipt_payload)
+        except Exception as _se:
+            env = {"signed": False, "honesty": "UNSIGNED — signer unavailable (%r)" % _se}
+        return JSONResponse({
+            "organ": "YUYAY v3 (HEART) · 13-axis conjunctive truth gate",
+            "verdict": verdict,
+            "conjunctive_pass": conjunctive_pass,
+            "rule": "pass = all(score[i] >= floor[i]) — NOT a weighted average",
+            "axes": axes,
+            "first_failing_axis": first_fail,
+            "lambda_advisory": round(lam, 6),
+            "lambda_am_gm": {"gm": round(lam, 6), "am": round(am, 6), "gm_le_am": lam <= am + 1e-9},
+            "receipt": env,
+            "honest": ("Conjunctive gate is REAL: a single axis below its floor denies the "
+                       "whole proposal. Lambda is advisory (Conjecture 1), never the gate. "
+                       "Receipt is ECDSA-P256/DSSE signed by the in-image key; verify against /cosign.pub."),
+        })
+
+    import sys as _du_sys
+    print("[a11oy] DEEP-UPGRADE live-data proxy + YUYAY gate registered: "
+          "/api/a11oy/v1/metrics, /api/a11oy/v1/prometheus, /api/a11oy/v1/yuyay/gate",
+          file=_du_sys.stderr)
+except Exception as _du_e:  # additive only — never crash the app
+    import sys as _du_sys, traceback as _du_tb
+    print(f"[a11oy] DEEP-UPGRADE live-data proxy NOT registered: {_du_e!r}", file=_du_sys.stderr)
+    _du_tb.print_exc()
+# === end DEEP-UPGRADE live-data proxy ===
+
+
 import threading as _pr_thr
 import math as _pr_math