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

Automated backend sync from szl-holdings/a11oy main via hf-sync-backend.
Updated (differed from the Space): Dockerfile, a11oy_ayllu.py, ayllu/backend.py, ayllu/loop.py, ayllu/lounge.py, research/__init__.py, research/a11oy_primary_project_registry.py, serve.py, szl3d_holographic.py, szl_be_hardening.py, szl_claim_rupture_gate.py, szl_hub.py, szl_waqay_security_loop.py
Deleted (gone from the repo + Dockerfile COPY set): (none)

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

Dockerfile

@@ -163,6 +163,16 @@ COPY knowledge.json ./static/knowledge.json
 # registers live. (dockerfile-copy-guard verifies these sources exist on main.)
 COPY a11oy_ayllu.py ./
 COPY ayllu/ ./ayllu/
+# Waqay Security Loop wave 15: pure read-only proposal contract.  The module
+# exposes zero external effectors; serve.py registers only its manifest GET.
+COPY szl_waqay_security_loop.py ./
+# Claim-integrity Rupture Gate wave 15: contract-only, external signals only,
+# unsigned deterministic receipts, zero effectors.
+COPY szl_claim_rupture_gate.py ./
+# Primary official project registry (51 records across 10 fields).  Runtime
+# serves the deterministic, unranked registry; optional live metadata remains a
+# bounded adapter and is not executed on anonymous public requests.
+COPY research/ ./research/
 # routers/ — Wave-K Dev4 serve.py decomposition (first bounded slice). serve.py
 # imports `from routers import lambda_bounty|research_3d|frontier_reads` (guarded)
 # and calls each register(app) BEFORE the SPA catch-all. This Dockerfile uses no
@@ -649,7 +659,9 @@ COPY benchmarks/pinn/run_bench.py ./benchmarks/pinn/run_bench.py
 # hf-sync mirrored) — same baked-only pattern as web/sda.html + web/immune.html;
 # declared in copy-sync-lockstep.json image_only_assets + hf-module-drift-allow.json
 # accepted_divergences.
-COPY web/formulas.html web/v4_fleet_panel.html web/operator.html web/fleet-c2.html web/living-anatomy.html web/nemo.html web/restraint.html web/restraint-bench.html web/holo.html web/constitution.html web/quant.html web/estate-hologram.html web/hologram.html web/signature-is-not-proof.html web/defense-readiness.html web/determinacy.html web/verify-receipt.html web/sda.html web/dns.html ./web/
+COPY web/formulas.html web/v4_fleet_panel.html web/operator.html web/fleet-c2.html web/living-anatomy.html web/nemo.html web/restraint.html web/restraint-bench.html web/holo.html web/constitution.html web/quant.html web/estate-hologram.html web/hologram.html web/determinacy.html web/verify-receipt.html web/sda.html web/dns.html ./web/
+COPY web/signature-is-not-proof.html ./web/signature-is-not-proof.html
+COPY web/defense-readiness.html ./web/defense-readiness.html
 # ADDITIVE (Lane A AGENTIC CORE, Dev A, 2026-06-14; QA9 restore 2026-06): the
 # resumable ReAct agent-loop core module. Per-file COPY (this Dockerfile uses no
 # COPY . .). a11oy_react_core.py is imported by serve.py (try/except guarded) and

a11oy_ayllu.py

@@ -24,9 +24,11 @@ from __future__ import annotations
 import base64
 import hashlib
 import json
+import os
 import threading
 import time
 import uuid
+from pathlib import Path
 from typing import Any, Dict, Optional
 
 # FastAPI resolves endpoint annotations with get_type_hints against THIS module's
@@ -69,6 +71,10 @@ __version__ = _AYLLU_VERSION
 MAX_PROMPT_CHARS = 6000
 COUNCIL_MAX = 5                                     # hard cap on participants / call
 COUNCIL_DEBATE_MAX = 3  # debate doubles model calls; tighter cap bounds cost
+ASK_MAX_TOKENS = 384
+ASK_TURN_TIMEOUT_S = 45.0
+COUNCIL_MAX_TOKENS = 192
+COUNCIL_TURN_TIMEOUT_S = 45.0
 COUNCIL_DEFAULT = ["Amaru", "Kamachiq", "Qhatuq"]  # architect · orchestrator · markets
 
 COUNCIL_CONTRACT_VERSION = "2.0"
@@ -114,9 +120,26 @@ def _receipt_sha(receipt: Optional[dict]) -> Optional[str]:
 
 
 def _make_receipt(payload: Dict[str, Any], sign_fn=None) -> Dict[str, Any]:
-    """Wrap payload in a DSSE envelope (honest UNSIGNED if no cosign key)."""
+    """Wrap payload in DSSE without overstating the signer's identity.
+
+    ``szl_dsse`` is the organization-key path: it signs only when an operator
+    injects the established Cosign private-key runtime secret. ``sign_fn`` is
+    the host's explicitly boot-ephemeral development signer. Prefer the former
+    only when its key is genuinely loadable, then fall back to the development
+    signer. With neither path available, emit an honest unsigned envelope.
+    """
     body = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
     honesty = "UNSIGNED — szl_dsse not present; no signature fabricated."
+    if _dsse is not None:
+        try:
+            signing_available = getattr(_dsse, "signing_available", None)
+            if (callable(signing_available) and signing_available()
+                    and hasattr(_dsse, "sign_payload")):
+                return _dsse.sign_payload(
+                    payload, "application/vnd.szl.receipt+json")
+        except Exception as exc:
+            honesty = (f"UNSIGNED — organization-key signer unavailable "
+                       f"({str(exc)[:80]}); no signature fabricated.")
     if callable(sign_fn):
         try:
             env = sign_fn(payload)
@@ -128,8 +151,9 @@ def _make_receipt(payload: Dict[str, Any], sign_fn=None) -> Dict[str, Any]:
                        "no signature fabricated.")
     if _dsse is not None:
         try:
-            # szl_dsse exposes sign_payload(); the former sign() call made every
-            # Ayllu receipt fall through to UNSIGNED even when the module existed.
+            # No organization key and no host development signer: use the
+            # canonical implementation only to construct its explicit UNSIGNED
+            # envelope (it never fabricates signature bytes).
             if hasattr(_dsse, "sign_payload"):
                 return _dsse.sign_payload(
                     payload, "application/vnd.szl.receipt+json")
@@ -151,7 +175,82 @@ def _sha256_json(value: Any) -> str:
     return hashlib.sha256(body).hexdigest()
 
 
-def council_manifest(ns: str = "a11oy") -> Dict[str, Any]:
+def _council_store_path(ns: str) -> tuple[str, str]:
+    """Resolve Council state without claiming an unverified durable mount.
+
+    Operators can name an exact path or an established data directory.  Local
+    development defaults to a gitignored directory beside this module, which
+    survives process restarts but is *not* claimed to survive a container or
+    Space rebuild.
+    """
+    exact = os.environ.get("A11OY_AYLLU_KHIPU_PATH")
+    if exact:
+        return exact, "A11OY_AYLLU_KHIPU_PATH"
+    data_dir = os.environ.get("A11OY_DATA_DIR")
+    if data_dir:
+        return os.path.join(data_dir, "ayllu", f"khipu_{ns}_council.sqlite3"), "A11OY_DATA_DIR"
+    khipu_dir = os.environ.get("SZL_KHIPU_DIR")
+    if khipu_dir:
+        return os.path.join(khipu_dir, f"khipu_{ns}_council.sqlite3"), "SZL_KHIPU_DIR"
+    return str(Path(__file__).resolve().parent / ".a11oy-state"
+               / f"khipu_{ns}_council.sqlite3"), "REPOSITORY_LOCAL_DEVELOPMENT_STATE"
+
+
+def _open_council_store(ns: str):
+    """Open the repository's tested durable Khipu implementation.
+
+    Returns ``(store, metadata)``.  Failure is explicit; the caller may still
+    use the legacy in-memory DAG but must report that downgrade.
+    """
+    path, configured_by = _council_store_path(ns)
+    try:
+        from szl_be_hardening import DurableKhipu
+        store = DurableKhipu("ayllu_council", ns=ns, path=path)
+        durable = store.backend in ("sqlite", "json")
+        meta = {
+            "backend": store.backend,
+            "durable": durable,
+            "configured_by": configured_by,
+            "survives_process_restart": durable,
+            "survives_redeploy": "NOT_VERIFIED",
+            "redeploy_requirement": (
+                "Mount the configured path on persistent storage; a writable "
+                "local/container filesystem alone does not prove redeploy persistence."
+            ),
+        }
+        return store, meta
+    except Exception as exc:
+        return None, {
+            "backend": "memory",
+            "durable": False,
+            "configured_by": configured_by,
+            "survives_process_restart": False,
+            "survives_redeploy": "NOT_VERIFIED",
+            "error": type(exc).__name__,
+            "honesty": "Durable Khipu unavailable; Council will use the in-process DAG.",
+        }
+
+
+def _council_store_metadata(store, fallback: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    if store is None:
+        return dict(fallback or {
+            "backend": "memory", "durable": False,
+            "survives_process_restart": False,
+            "survives_redeploy": "NOT_VERIFIED",
+        })
+    backend = getattr(store, "backend", "memory")
+    base = dict(fallback or {})
+    base.update({
+        "backend": backend,
+        "durable": backend in ("sqlite", "json"),
+        "survives_process_restart": backend in ("sqlite", "json"),
+        "survives_redeploy": "NOT_VERIFIED",
+    })
+    return base
+
+
+def council_manifest(ns: str = "a11oy",
+                     chain_storage: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """Side-effect-free, investor-readable contract for the bounded council."""
     base = f"/api/{ns}/v1/ayllu"
     return {
@@ -174,7 +273,7 @@ def council_manifest(ns: str = "a11oy") -> Dict[str, Any]:
             "persona/model/round/output digest per turn",
             "Nemo governed-route decision and DSSE receipt",
             "deterministic replay key over participants, mode, and output digests",
-            "in-process Khipu chain receipt (resets on process restart)",
+            "Khipu chain receipt with runtime-reported storage backend and durability",
             "outer Council DSSE receipt",
         ],
         "limits": {
@@ -182,10 +281,20 @@ def council_manifest(ns: str = "a11oy") -> Dict[str, Any]:
             "participants": COUNCIL_MAX,
             "debate_participants": COUNCIL_DEBATE_MAX,
             "debate_rounds": 2,
+            "ask_tokens_per_turn": ASK_MAX_TOKENS,
+            "ask_timeout_s": ASK_TURN_TIMEOUT_S,
+            "council_tokens_per_turn": COUNCIL_MAX_TOKENS,
+            "council_timeout_s": COUNCIL_TURN_TIMEOUT_S,
+            "round_fanout": "CONCURRENT_BOUNDED",
             "effectors": "none",
             "decision_state": "PROPOSAL_ONLY",
             "semantic_consensus": "NOT_MEASURED",
-            "chain_persistence": "IN_MEMORY_RESETS_ON_RESTART",
+            "chain_storage": chain_storage or {
+                "backend": "NOT_INSPECTED",
+                "durable": "NOT_INSPECTED",
+                "survives_process_restart": "NOT_INSPECTED",
+                "survives_redeploy": "NOT_VERIFIED",
+            },
         },
         "reproduce": {
             "manifest": base + "/council/manifest",
@@ -251,6 +360,11 @@ def _build_council_contract(prompt: str, result: Dict[str, Any],
             "round": turn.get("round"),
             "model": turn.get("model"),
             "stub": bool(turn.get("stub")),
+            "timeout": bool(turn.get("timeout", False)),
+            "token_budget": turn.get("token_budget"),
+            "timeout_s": turn.get("timeout_s"),
+            "correctness_state": ("NOT_APPLICABLE_STUB" if bool(turn.get("stub"))
+                                  else "UNVERIFIED_MODEL_OUTPUT"),
             "output_sha256": (hashlib.sha256(str(answer).encode("utf-8")).hexdigest()
                               if answer is not None else None),
             "energy_receipt_sha256": _receipt_sha(turn.get("energy_receipt")),
@@ -263,8 +377,11 @@ def _build_council_contract(prompt: str, result: Dict[str, Any],
         "turns": turn_evidence,
     }
     live_turns = sum(1 for t in turn_evidence if not t["stub"])
+    timeout_turns = sum(1 for t in turn_evidence if t["timeout"])
     if not turn_evidence:
         evidence_state = "UNAVAILABLE"
+    elif timeout_turns and not live_turns:
+        evidence_state = "UNAVAILABLE"
     elif live_turns == len(turn_evidence):
         evidence_state = "LIVE"
     elif live_turns:
@@ -278,6 +395,7 @@ def _build_council_contract(prompt: str, result: Dict[str, Any],
         "decision_state": "PROPOSAL_ONLY",
         "approval_state": "HUMAN_REVIEW_REQUIRED",
         "evidence_state": evidence_state,
+        "correctness_state": "NOT_VERIFIED",
         "prompt_sha256": replay_material["prompt_sha256"],
         "turn_evidence": turn_evidence,
         "routing": nemo_route,
@@ -297,6 +415,10 @@ def _build_council_contract(prompt: str, result: Dict[str, Any],
             "participants_max": COUNCIL_MAX,
             "debate_participants_max": COUNCIL_DEBATE_MAX,
             "rounds_max": 2,
+            "tokens_per_turn_max": COUNCIL_MAX_TOKENS,
+            "turn_timeout_s": COUNCIL_TURN_TIMEOUT_S,
+            "round_fanout": "CONCURRENT_BOUNDED",
+            "timeout_turns": timeout_turns,
             "model_calls_observed": len(turn_evidence),
             "external_effectors": 0,
             "automatic_commit": False,
@@ -320,18 +442,51 @@ def _build_council_contract(prompt: str, result: Dict[str, Any],
     }
 
 
-def _mint_council_chain(contract: Dict[str, Any], ns: str = "a11oy") -> Dict[str, Any]:
-    """Append the proposal receipt to the shared in-process Khipu chain."""
+def _mint_council_chain(contract: Dict[str, Any], ns: str = "a11oy",
+                        store=None,
+                        storage_meta: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """Append the proposal receipt to durable Khipu, with honest fallback."""
+    payload = {
+        "contract_version": contract.get("contract_version"),
+        "decision_state": contract.get("decision_state"),
+        "evidence_state": contract.get("evidence_state"),
+        "prompt_sha256": contract.get("prompt_sha256"),
+        "replay_key": (contract.get("replay") or {}).get("key"),
+    }
+    if store is not None:
+        try:
+            receipt = store.emit("ayllu.council.proposal", payload)
+            ok, depth, first_break = store.verify()
+            meta = _council_store_metadata(store, storage_meta)
+            return {
+                "state": "LIVE",
+                "organ": "ayllu_council",
+                "receipt_id": receipt.get("digest"),
+                "seq": receipt.get("seq"),
+                "chain_verified": bool(ok),
+                "first_break_seq": first_break,
+                "depth": depth,
+                "persistence": ("PROCESS_RESTART_DURABLE_LOCAL_DISK"
+                                if meta["durable"] else
+                                "IN_MEMORY_RESETS_ON_RESTART"),
+                "storage": meta,
+            }
+        except Exception as exc:
+            # Do not lose the advisory response merely because durable storage
+            # failed. Fall through to the legacy in-process chain and report the
+            # exact downgrade in the returned evidence.
+            storage_meta = {
+                **(storage_meta or {}),
+                "backend": "memory",
+                "durable": False,
+                "survives_process_restart": False,
+                "survives_redeploy": "NOT_VERIFIED",
+                "durable_append_error": type(exc).__name__,
+            }
     try:
         import szl_khipu
         dag = szl_khipu.get_dag("ayllu_council", ns=ns)
-        receipt = dag.emit("ayllu.council.proposal", {
-            "contract_version": contract.get("contract_version"),
-            "decision_state": contract.get("decision_state"),
-            "evidence_state": contract.get("evidence_state"),
-            "prompt_sha256": contract.get("prompt_sha256"),
-            "replay_key": (contract.get("replay") or {}).get("key"),
-        })
+        receipt = dag.emit("ayllu.council.proposal", payload)
         chain = dag.verify_chain()
         return {
             "state": "LIVE",
@@ -341,6 +496,7 @@ def _mint_council_chain(contract: Dict[str, Any], ns: str = "a11oy") -> Dict[str
             "chain_verified": bool(chain.get("ok")),
             "depth": dag.depth(),
             "persistence": "IN_MEMORY_RESETS_ON_RESTART",
+            "storage": _council_store_metadata(None, storage_meta),
         }
     except Exception as exc:
         return {
@@ -349,6 +505,7 @@ def _mint_council_chain(contract: Dict[str, Any], ns: str = "a11oy") -> Dict[str
             "receipt_id": None,
             "error": type(exc).__name__,
             "honesty": "Khipu append unavailable; no chain receipt fabricated.",
+            "storage": _council_store_metadata(None, storage_meta),
         }
 
 
@@ -384,6 +541,7 @@ select[multiple]{height:auto}
 textarea{resize:vertical;margin-bottom:8px}
 button{background:var(--teal);color:#04140f;border:0;border-radius:7px;padding:8px 16px;
 font-weight:700;cursor:pointer}
+button:disabled{cursor:wait;opacity:.55}
 button.mini{background:transparent;color:var(--teal);border:1px solid var(--line);padding:3px 9px;
 font-weight:600;font-size:12px}
 .hint{color:var(--dim);font-size:12px;margin:0 0 8px}
@@ -432,6 +590,21 @@ section[id]{scroll-margin-top:72px}
 .tgl{display:flex;gap:7px;align-items:center;color:var(--dim);font-size:13px;margin:0 0 8px}
 .tgl input{width:auto}
 .prov{color:var(--dim);font-size:11px;margin-top:14px;line-height:1.6}
+@media (max-width:720px){
+ main{padding:24px 14px}
+ .tb-wrap{padding:9px 14px;flex-wrap:nowrap}
+ .tb-brand{flex:0 0 auto}
+ .tb-nav{flex:1 1 auto;min-width:0;flex-wrap:nowrap;overflow-x:auto;
+  -webkit-overflow-scrolling:touch;scrollbar-width:none}
+ .tb-nav::-webkit-scrollbar{display:none}
+ .tb-nav a{flex:0 0 auto}
+ .card{padding:14px}
+ .row{display:grid;grid-template-columns:minmax(0,1fr)}
+ .row select,.row input{width:100%;min-width:0}
+ table{display:block;overflow-x:auto;-webkit-overflow-scrolling:touch;white-space:nowrap}
+ .meta{margin-left:0;width:100%}
+ section[id]{scroll-margin-top:58px}
+}
 </style></head><body>
 <header class="topbar"><div class="tb-wrap">
 <a class="tb-brand" href="/ayllu">Ayllu <span id="badge" class="badge">…</span></a>
@@ -446,13 +619,13 @@ section[id]{scroll-margin-top:72px}
 <section class="card" id="sec-ask">
   <h2>Ask a persona</h2>
   <div class="row">
-    <select id="persona"></select>
+    <select id="persona" aria-label="Persona"></select>
     <input id="difficulty" type="number" min="0" max="1" step="0.1"
-           placeholder="difficulty 0–1 (optional)">
+           placeholder="difficulty 0–1 (optional)" aria-label="Difficulty from zero to one">
   </div>
-  <textarea id="askprompt" rows="3" placeholder="Ask a persona…"></textarea>
+  <textarea id="askprompt" rows="3" placeholder="Ask a persona…" aria-label="Prompt for the selected persona"></textarea>
   <button id="askbtn">Ask</button>
-  <div id="askout" class="out"></div>
+  <div id="askout" class="out" aria-live="polite"></div>
 </section>
 
 <section class="card" id="sec-council">
@@ -465,12 +638,12 @@ section[id]{scroll-margin-top:72px}
   <p class="hint">Defaults to 3 core personas; select up to 5 (⌘/Ctrl-click). Fan-out is
   capped to protect cost. Debate mode runs exactly two bounded rounds
   (after arXiv:2305.14325) and is capped to 3 personas.</p>
-  <select id="councilsel" multiple size="6"></select>
+  <select id="councilsel" multiple size="6" aria-label="Council personas"></select>
   <label class="tgl"><input type="checkbox" id="debate">
   Debate mode — positions, then explicit dissent &amp; converge (2× cost)</label>
-  <textarea id="councilprompt" rows="3" placeholder="A question for the council…"></textarea>
+  <textarea id="councilprompt" rows="3" placeholder="A question for the council…" aria-label="Question for the council"></textarea>
   <button id="councilbtn">Convene</button>
-  <div id="councilout" class="out"></div>
+  <div id="councilout" class="out" aria-live="polite"></div>
 </section>
 
 <section class="card" id="sec-roster">
@@ -534,8 +707,12 @@ instilled knowledge (cited text in the system prompt); nothing here was "trained
 const NS="__NS__";
 const api = p => `/api/${NS}/v1/ayllu/`+p;
 const gapi = p => `/api/${NS}/v1/`+p;
-async function j(url,opts){const r=await fetch(url,opts);
-  let d={};try{d=await r.json();}catch(e){}return {ok:r.ok,status:r.status,data:d};}
+async function j(url,opts){
+  try{const r=await fetch(url,opts);let d={};
+    try{d=await r.json();}catch(e){}
+    return {ok:r.ok,status:r.status,data:d};
+  }catch(e){return {ok:false,status:'network',data:{error:'request unavailable'}};}
+}
 function esc(s){return (s==null?'':String(s)).replace(/[&<>]/g,
   c=>({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));}
 function hue(n){let h=0;for(const c of String(n))h=(h*31+c.charCodeAt(0))%360;return h;}
@@ -554,8 +731,14 @@ function renderTurn(t){
        + `<div class="ans">${ans}</div></div>`;
 }
 async function loadRoster(){
-  const {ok,data}=await j(api('roster'));
-  if(!ok)return;
+  const {ok,status,data}=await j(api('roster'));
+  if(!ok){
+    document.getElementById('count').textContent='—';
+    const badge=document.getElementById('badge');
+    badge.textContent='UNAVAILABLE';badge.className='badge warn';
+    badge.title='roster endpoint unavailable ('+String(status)+') — no live state fabricated';
+    return;
+  }
   document.getElementById('count').textContent=data.count;
   const b=data.backend||{}, badge=document.getElementById('badge'), mode=b.mode||'?';
   badge.textContent=mode.toUpperCase();
@@ -575,15 +758,17 @@ async function loadRoster(){
   document.querySelector('#roster tbody').innerHTML=rows.join('');
 }
 document.getElementById('askbtn').onclick=async()=>{
+  const btn=document.getElementById('askbtn');
   const persona=document.getElementById('persona').value;
   const prompt=document.getElementById('askprompt').value.trim();
   const d=document.getElementById('difficulty').value;
   const out=document.getElementById('askout');
   if(!prompt){out.innerHTML='<span class="err">enter a prompt</span>';return;}
-  out.textContent='…thinking';
+  out.textContent='…thinking';btn.disabled=true;out.setAttribute('aria-busy','true');
   const body={persona,prompt}; if(d!=='')body.difficulty=parseFloat(d);
   const {ok,status,data}=await j(api('ask'),{method:'POST',
     headers:{'content-type':'application/json'},body:JSON.stringify(body)});
+  btn.disabled=false;out.removeAttribute('aria-busy');
   if(!ok){out.innerHTML='<span class="err">'+esc(data.error||('HTTP '+status))+'</span>'
     +(data.retry_after_s?(' (retry in '+data.retry_after_s+'s)'):'');return;}
   const r=data.receipt||{}, sig=r.signed?'signed':'UNSIGNED';
@@ -591,15 +776,18 @@ document.getElementById('askbtn').onclick=async()=>{
     +`<div class="rcpt">receipt: ${sig} · ask ${esc(String(data.ask_id)).slice(0,8)}</div>`;
 };
 document.getElementById('councilbtn').onclick=async()=>{
+  const btn=document.getElementById('councilbtn');
   const prompt=document.getElementById('councilprompt').value.trim();
   const out=document.getElementById('councilout');
   if(!prompt){out.innerHTML='<span class="err">enter a prompt</span>';return;}
   const picks=[...document.getElementById('councilsel').selectedOptions].map(o=>o.value);
   const debate=document.getElementById('debate').checked;
   out.textContent=debate?'…convening (debate: 2 bounded rounds)':'…convening';
+  btn.disabled=true;out.setAttribute('aria-busy','true');
   const body={prompt}; if(picks.length)body.personas=picks; if(debate)body.debate=true;
   const {ok,status,data}=await j(api('council'),{method:'POST',
     headers:{'content-type':'application/json'},body:JSON.stringify(body)});
+  btn.disabled=false;out.removeAttribute('aria-busy');
   if(!ok){out.innerHTML='<span class="err">'+esc(data.error||('HTTP '+status))+'</span>'
     +(data.retry_after_s?(' (retry in '+data.retry_after_s+'s)'):'');return;}
   const res=data.result||{}, rounds=res.rounds||[], c=data.contract||{};
@@ -607,10 +795,10 @@ document.getElementById('councilbtn').onclick=async()=>{
   const r1=rounds.filter(t=>(t.round||1)===1), r2=rounds.filter(t=>t.round===2);
   const route=c.routing||{}, outer=data.receipt||{};
   const contract=`<div class="contract"><b>${esc(c.decision_state||'PROPOSAL_ONLY')}</b>`
-    +` · evidence ${esc(c.evidence_state||'UNKNOWN')}`
-    +` · human review ${c.human_checkpoint&&c.human_checkpoint.required?'REQUIRED':'UNKNOWN'}`
+    +` · evidence ${esc(c.evidence_state||'UNKNOWN')}`
+    +` · human review ${c.human_checkpoint&&c.human_checkpoint.required?'REQUIRED':'UNKNOWN'}`
     +`<br>Nemo: ${esc((route.experts_selected||[]).join(' + ')||route.state||'unavailable')}`
-    +` · route ${esc(route.state||'UNKNOWN')} · outer receipt ${outer.signed?'SIGNED':'UNSIGNED'}`
+    +` · route ${esc(route.state||'UNKNOWN')} · outer receipt ${outer.signed?'SIGNED':'UNSIGNED'}`
     +`<br>replay ${esc((c.replay&&c.replay.key)||'unavailable')}`
     +`<br>semantic consensus: ${esc((c.semantic_consensus&&c.semantic_consensus.state)||'NOT_MEASURED')}`
     +`</div>`;
@@ -706,6 +894,13 @@ def register(app, ns: str = "a11oy") -> str:
     from fastapi import Request
     from fastapi.responses import HTMLResponse, JSONResponse
 
+    council_store, council_storage = _open_council_store(ns)
+    try:
+        app.state.ayllu_council_khipu = council_store
+        app.state.ayllu_council_khipu_storage = council_storage
+    except Exception:
+        pass
+
     def _runtime_signer(request: "Request"):
         """Resolve the host signer lazily: Ayllu registers before serve.py creates it."""
         try:
@@ -727,7 +922,9 @@ def register(app, ns: str = "a11oy") -> str:
         })
 
     async def _council_manifest(request: "Request") -> "JSONResponse":
-        return JSONResponse(council_manifest(ns))
+        storage = getattr(request.app.state, "ayllu_council_khipu_storage",
+                          council_storage)
+        return JSONResponse(council_manifest(ns, storage))
 
     async def _ask(request: "Request") -> "JSONResponse":
         ok, retry = _ASK_BUCKET.check()
@@ -763,7 +960,12 @@ def register(app, ns: str = "a11oy") -> str:
             return JSONResponse(
                 {"error": "'difficulty' must be a number between 0 and 1"},
                 status_code=422)
-        turn = await run_turn(p, prompt, model_complete=_backend.model_complete,
+        async def _ask_complete(**kwargs):
+            return await _backend.model_complete(
+                **kwargs, max_tokens=ASK_MAX_TOKENS,
+                timeout_s=ASK_TURN_TIMEOUT_S)
+
+        turn = await run_turn(p, prompt, model_complete=_ask_complete,
                               difficulty=difficulty)
         ask_id = str(uuid.uuid4())
         receipt = _make_receipt({
@@ -825,16 +1027,24 @@ def register(app, ns: str = "a11oy") -> str:
             return JSONResponse(
                 {"error": "no known personas in request",
                  "known": [x.name for x in ROSTER]}, status_code=422)
-        result = await _LOUNGE.deliberate(prompt, personas,
-                                          model_complete=_backend.model_complete,
-                                          debate=debate)
+        async def _council_complete(**kwargs):
+            return await _backend.model_complete(
+                **kwargs, max_tokens=COUNCIL_MAX_TOKENS,
+                timeout_s=COUNCIL_TURN_TIMEOUT_S)
+
+        result = await _LOUNGE.deliberate(
+            prompt, personas, model_complete=_council_complete, debate=debate)
         if cap_note:
             result["cap_note"] = cap_note
         council_id = str(uuid.uuid4())
         signer = _runtime_signer(request)
         nemo_route = _nemo_council_route(prompt, sign_fn=signer)
         contract = _build_council_contract(prompt, result, nemo_route)
-        contract["chain"] = _mint_council_chain(contract, ns=ns)
+        store = getattr(request.app.state, "ayllu_council_khipu", council_store)
+        storage = getattr(request.app.state, "ayllu_council_khipu_storage",
+                          council_storage)
+        contract["chain"] = _mint_council_chain(
+            contract, ns=ns, store=store, storage_meta=storage)
         receipt_body = {
             "council_id": council_id,
             "prompt_sha256": hashlib.sha256(prompt.encode()).hexdigest(),
@@ -886,5 +1096,7 @@ def register(app, ns: str = "a11oy") -> str:
         f"ok — ayllu registered: {len(ROSTER)} personas; live model backend "
         f"({_backend.backend_status().get('mode')}); bounded-autonomy Λ-gate; "
         f"/ayllu + /api/{ns}/v1/ayllu/roster|ask|council|lounge; "
-        f"debate-mode council; version={__version__}"
+        f"debate-mode council; council_khipu={council_storage.get('backend')} "
+        f"(process_restart_durable={council_storage.get('durable')}, "
+        f"redeploy=NOT_VERIFIED); version={__version__}"
     )

ayllu/backend.py

@@ -13,6 +13,7 @@ honest stub dict — it NEVER fabricates an answer and NEVER claims a wiring it
 """
 from __future__ import annotations
 
+import asyncio
 import contextlib
 from typing import Any, Optional
 
@@ -39,10 +40,15 @@ def backend_status() -> dict[str, Any]:
         orch_err = str(exc)[:160]
 
     has_cred = False
+    local_ready = False
+    backend_ready = False
     cred_checked = False
     if orch is not None:
         try:
-            has_cred = bool(orch.has_inference_credential())
+            has_cred = bool(orch._resolve_hf_token()) or any(
+                orch._resolve_provider_keys().values())
+            _base, local_ready = orch._serving_base()
+            backend_ready = bool(orch.has_inference_credential())
             cred_checked = True
         except Exception:
             cred_checked = False
@@ -51,7 +57,7 @@ def backend_status() -> dict[str, Any]:
         mode = "unavailable"
     elif not cred_checked:
         mode = "unknown"
-    elif has_cred:
+    elif backend_ready:
         mode = "live"
     else:
         mode = "stub"
@@ -61,15 +67,18 @@ def backend_status() -> dict[str, Any]:
         "orchestrator_error": orch_err,
         "credential_checked": cred_checked,
         "has_credential": has_cred,
+        "local_backend_ready": local_ready,
+        "backend_ready": backend_ready,
         "mode": mode,
         "note": {
             "unavailable": "a11oy_code_orchestrator not importable — ask/council return "
                            "an honest stub.",
             "unknown": "orchestrator present but credential state could not be read.",
-            "live": "real model answers via a11oy routing + energy receipts; ongoing "
-                    "token cost.",
-            "stub": "no inference credential set on this Space — clearly-labeled "
-                    "deterministic stub, no fabrication.",
+            "live": ("real model answers via a11oy routing + receipts; source is a "
+                     "reachable local backend or a credentialed remote provider. "
+                     "Outputs remain unverified model text."),
+            "stub": ("no reachable local backend or remote inference credential — "
+                     "clearly-labeled deterministic stub, no fabrication."),
         }.get(mode, ""),
         "backend": "a11oy_code_orchestrator.agent_model_complete",
     }
@@ -83,6 +92,7 @@ async def model_complete(
     persona: Optional[str] = None,
     max_tokens: int = 1000,
     temperature: float = 0.4,
+    timeout_s: float = 45.0,
     **_ignored: Any,
 ) -> dict[str, Any]:
     """Adapter matching ayllu.loop.run_turn's model_complete contract.
@@ -105,20 +115,57 @@ async def model_complete(
                 "model": "unavailable",
                 "stub": True,
             }
+        bounded_tokens = max(1, min(int(max_tokens), 2048))
+        bounded_timeout = max(0.1, min(float(timeout_s), 120.0))
         try:
-            result = await _o.agent_model_complete(
-                messages, max_tokens=max_tokens, temperature=temperature)
+            result = await asyncio.wait_for(
+                _o.agent_model_complete(
+                    messages, max_tokens=bounded_tokens, temperature=temperature),
+                timeout=bounded_timeout,
+            )
+        except asyncio.TimeoutError:
+            return {
+                "text": None,
+                "model": "timeout",
+                "stub": True,
+                "timeout": True,
+                "token_budget": bounded_tokens,
+                "timeout_s": bounded_timeout,
+                "honesty": (
+                    f"model turn exceeded the {bounded_timeout:g}s deadline; "
+                    "the request was cancelled and no answer was fabricated"
+                ),
+            }
         except Exception as exc:
             return {
-                "text": f"[honest error: agent_model_complete raised: {str(exc)[:160]}]",
+                "text": None,
                 "model": "error",
                 "stub": True,
+                "timeout": False,
+                "token_budget": bounded_tokens,
+                "timeout_s": bounded_timeout,
+                "honesty": (
+                    f"agent_model_complete raised: {str(exc)[:160]}; "
+                    "no answer was fabricated"
+                ),
             }
         if not isinstance(result, dict):
-            return {"text": str(result), "model": "unknown", "stub": True}
+            return {
+                "text": None,
+                "model": "unknown",
+                "stub": True,
+                "timeout": False,
+                "token_budget": bounded_tokens,
+                "timeout_s": bounded_timeout,
+                "honesty": "model backend returned a non-contract value; no answer was used",
+            }
         return {
             "text": result.get("text", ""),
             "model": result.get("model"),
             "stub": bool(result.get("stub")),
+            "timeout": bool(result.get("timeout", False)),
+            "token_budget": bounded_tokens,
+            "timeout_s": bounded_timeout,
+            "honesty": result.get("honesty"),
             "energy_receipt": result.get("energy_receipt"),
         }

ayllu/loop.py

@@ -70,6 +70,9 @@ async def run_turn(
     answer: Optional[str] = None
     model: Optional[str] = None
     stub: Optional[bool] = None
+    timed_out = False
+    token_budget: Optional[int] = None
+    timeout_s: Optional[float] = None
     energy_receipt: Any = None
 
     if model_complete is None:
@@ -101,11 +104,16 @@ async def run_turn(
                 answer = result.get("text")
                 model = result.get("model")
                 stub = result.get("stub")
+                timed_out = bool(result.get("timeout", False))
+                token_budget = result.get("token_budget")
+                timeout_s = result.get("timeout_s")
                 energy_receipt = result.get("energy_receipt")
             else:
                 answer = str(result)
             honesty = "answer produced by a11oy's model backend" + (
                 " (clearly-labeled stub — no inference credential set)" if stub else "")
+            if isinstance(result, dict) and result.get("honesty"):
+                honesty = str(result["honesty"])
         except Exception as exc:
             honesty = (f"model backend raised: {str(exc)[:120]} "
                        "(honest — no fabricated answer)")
@@ -122,6 +130,9 @@ async def run_turn(
         "answer": answer,
         "model": model,
         "stub": stub,
+        "timeout": timed_out,
+        "token_budget": token_budget,
+        "timeout_s": timeout_s,
         "energy_receipt": energy_receipt,
         "honesty": honesty,
         "evidence": [],

ayllu/lounge.py

@@ -8,6 +8,7 @@ per persona — and never fabricates when no backend is injected.
 """
 from __future__ import annotations
 
+import asyncio
 import time
 from typing import Any
 
@@ -39,18 +40,21 @@ class Lounge:
     ) -> dict[str, Any]:
         from .loop import run_turn
 
-        rounds = []
-        for p in personas:
-            turn = await run_turn(
-                p, prompt,
-                model_complete=model_complete,
+        async def _one_turn(p, turn_prompt: str):
+            return await run_turn(
+                p, turn_prompt, model_complete=model_complete,
                 difficulty=difficulty,
-                two_person_attested=two_person_attested,
-            )
+                two_person_attested=two_person_attested)
+
+        # A council round is independent fan-out. Preserve input order in the
+        # evidence, but spend one bounded deadline instead of N sequential ones.
+        rounds = list(await asyncio.gather(*(
+            _one_turn(p, prompt) for p in personas
+        )))
+        for p, turn in zip(personas, rounds):
             turn["round"] = 1
             src = "brain" if turn.get("answer") is not None else "persona-fallback"
             self.post(p.name, turn.get("answer") or turn.get("honesty"), source=src)
-            rounds.append(turn)
 
         mode = "single-round"
         # Debate-then-converge (after arXiv:2305.14325, Multiagent Debate): one
@@ -65,6 +69,7 @@ class Lounge:
             ]
             if len(positions) >= 2:
                 mode = "debate"
+                debate_jobs = []
                 for p in personas:
                     peers = "\n\n".join(
                         f"[{name}] {ans[:1200]}" for name, ans in positions
@@ -77,12 +82,11 @@ class Lounge:
                         "State explicitly where you agree or dissent, then give "
                         "your revised answer. Honest dissent beats false consensus."
                     )
-                    turn = await run_turn(
-                        p, debate_prompt,
-                        model_complete=model_complete,
-                        difficulty=difficulty,
-                        two_person_attested=two_person_attested,
-                    )
+                    debate_jobs.append((p, debate_prompt))
+                revised = list(await asyncio.gather(*(
+                    _one_turn(p, turn_prompt) for p, turn_prompt in debate_jobs
+                )))
+                for (p, _turn_prompt), turn in zip(debate_jobs, revised):
                     turn["round"] = 2
                     src = ("brain" if turn.get("answer") is not None
                            else "persona-fallback")

research/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Research-layer modules for source-cited A11oy experiments."""
+

research/a11oy_primary_project_registry.py

@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+# Change-class: ADDITIVE - research registry only; no route or UI registration.
+"""Primary-source project registry with honest live GitHub metadata.
+
+This module records projects and organizations, not individual people.  The
+static registry is deliberately unranked: inclusion means "study this primary
+source", not "this is objectively first".  Every adaptation is DECLARED and
+attributed ``STUDIED_NOT_COPIED``.
+
+Live stars, detected SPDX license, and the default-branch revision are fetched
+from GitHub's API only when explicitly requested.  They are never embedded in
+the registry.  A failed or disabled fetch returns null values carrying the
+``UNAVAILABLE`` label; it never reuses an expired value as if it were current.
+
+Taxonomy home: research/.  Pure Python standard library; no HTTP framework.
+"""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from copy import deepcopy
+from datetime import datetime, timezone
+import json
+import os
+import re
+import threading
+import time
+from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Tuple
+from urllib.parse import quote, urlparse
+from urllib.request import Request, urlopen
+
+
+REGISTRY_VERSION = "wave-13-primary-projects-v1"
+ATTRIBUTION = "STUDIED_NOT_COPIED"
+STATIC_LABEL = "DECLARED"
+LIVE_LABEL = "MEASURED"
+UNAVAILABLE = "UNAVAILABLE"
+DEFAULT_TIMEOUT_S = 5.0
+DEFAULT_TTL_S = 15 * 60.0
+MAX_RESPONSE_BYTES = 2_000_000
+
+
+_FIELDS: Tuple[Mapping[str, str], ...] = (
+    {"id": "reasoning_math", "name": "Reasoning & math"},
+    {"id": "quantization_efficient_inference", "name": "Quantization & efficient inference"},
+    {"id": "retrieval_memory_long_context", "name": "Retrieval, memory & long context"},
+    {"id": "multimodal_vision", "name": "Multimodal & vision"},
+    {"id": "biomed_science", "name": "Biomed & science"},
+    {"id": "security_red_team", "name": "Security & red-team"},
+    {"id": "datasets_curation", "name": "Datasets & curation"},
+    {"id": "sovereign_on_metal_serving", "name": "Sovereign / on-metal serving"},
+    {
+        "id": "verifiable_orchestration_provenance",
+        "name": "Verifiable orchestration & provenance",
+    },
+    {"id": "formal_proof_training", "name": "Formal proof & training"},
+)
+
+
+def _project(
+    project_id: str,
+    field: str,
+    project: str,
+    organization: str,
+    repo: str,
+    license_expected: str,
+    primary_paper_docs: Iterable[str],
+    adaptation: str,
+) -> Mapping[str, Any]:
+    return {
+        "id": project_id,
+        "field": field,
+        "project": project,
+        "organization": organization,
+        "canonical_repo_url": repo,
+        "license_expected": license_expected,
+        "primary_paper_docs": tuple(primary_paper_docs),
+        "szl_adaptation_status": STATIC_LABEL,
+        "szl_adaptation": adaptation,
+        "attribution": ATTRIBUTION,
+    }
+
+
+# Licenses here are expectations to compare against the live API result, not a
+# substitute for inspecting the license at the fetched revision.  UNKNOWN is
+# intentional wherever the repository/model license is non-SPDX or uncertain.
+_PROJECTS: Tuple[Mapping[str, Any], ...] = (
+    # Reasoning & math
+    _project("qwen3", "reasoning_math", "Qwen3", "QwenLM", "https://github.com/QwenLM/Qwen3", "Apache-2.0", ("https://arxiv.org/abs/2505.09388",), "Route bounded math prompts through formula-aware evaluation and attach A11oy provenance."),
+    _project("deepseek-r1", "reasoning_math", "DeepSeek-R1", "deepseek-ai", "https://github.com/deepseek-ai/DeepSeek-R1", "MIT", ("https://arxiv.org/abs/2501.12948",), "Evaluate explicit reasoning traces against locked-formula and restraint gates before acceptance."),
+    _project("kimi-k2-5", "reasoning_math", "Kimi K2.5", "MoonshotAI", "https://github.com/MoonshotAI/Kimi-K2.5", "UNKNOWN", ("https://github.com/MoonshotAI/Kimi-K2.5/blob/main/tech_report.pdf",), "Study long-horizon decomposition while preserving A11oy budgets, receipts, and human override."),
+    _project("glm-4-7", "reasoning_math", "GLM-4.7 (GLM-4.5 repository)", "zai-org", "https://github.com/zai-org/GLM-4.5", "MIT", ("https://github.com/zai-org/GLM-4.5",), "Compare tool-using math runs with the same local formula corpus and honesty labels."),
+    _project("minimax-m2-5", "reasoning_math", "MiniMax M2.5", "MiniMax-AI", "https://github.com/MiniMax-AI/MiniMax-M2.5", "UNKNOWN", ("https://github.com/MiniMax-AI/MiniMax-M2.5",), "Test agentic reasoning under explicit step, token, thermal, and energy budgets."),
+
+    # Quantization & efficient inference
+    _project("llama-cpp-inference", "quantization_efficient_inference", "llama.cpp", "ggml-org", "https://github.com/ggml-org/llama.cpp", "MIT", ("https://github.com/ggml-org/llama.cpp/tree/master/examples/quantize",), "Expose local quantization profiles through a hardware-probed A11oy serving plan."),
+    _project("vllm-inference", "quantization_efficient_inference", "vLLM", "vllm-project", "https://github.com/vllm-project/vllm", "Apache-2.0", ("https://github.com/vllm-project/vllm/tree/main/docs",), "Adapt paged serving concepts behind A11oy admission control and measured resource receipts."),
+    _project("sglang-inference", "quantization_efficient_inference", "SGLang", "sgl-project", "https://github.com/sgl-project/sglang", "Apache-2.0", ("https://github.com/sgl-project/sglang/tree/main/docs",), "Study structured serving and prefix reuse with tenant isolation and bounded caches."),
+    _project("bitnet", "quantization_efficient_inference", "BitNet", "microsoft", "https://github.com/microsoft/BitNet", "MIT", ("https://arxiv.org/abs/2402.17764",), "Benchmark low-bit kernels on the actual laptop before declaring any supported profile."),
+    _project("tensorrt-llm", "quantization_efficient_inference", "TensorRT-LLM", "NVIDIA", "https://github.com/NVIDIA/TensorRT-LLM", "Apache-2.0", ("https://github.com/NVIDIA/TensorRT-LLM/tree/main/docs",), "Compare engine plans with reproducible revisions, VRAM evidence, and measured throughput."),
+
+    # Retrieval, memory & long context
+    _project("cognee", "retrieval_memory_long_context", "cognee", "topoteretes", "https://github.com/topoteretes/cognee", "Apache-2.0", ("https://github.com/topoteretes/cognee/tree/main/docs",), "Study graph-backed ingestion while retaining A11oy source digests and deletion controls."),
+    _project("letta", "retrieval_memory_long_context", "Letta", "letta-ai", "https://github.com/letta-ai/letta", "Apache-2.0", ("https://github.com/letta-ai/letta/tree/main/docs",), "Adapt bounded agent memory with explicit provenance, retention, and operator-visible state."),
+    _project("mem0", "retrieval_memory_long_context", "Mem0", "mem0ai", "https://github.com/mem0ai/mem0", "Apache-2.0", ("https://github.com/mem0ai/mem0/tree/main/docs",), "Evaluate memory extraction behind consent, namespace isolation, and auditable forgetting."),
+    _project("graphiti", "retrieval_memory_long_context", "Graphiti", "getzep", "https://github.com/getzep/graphiti", "Apache-2.0", ("https://github.com/getzep/graphiti",), "Study temporal knowledge graphs with source-time and ingestion-time retained separately."),
+    _project("zep-ce", "retrieval_memory_long_context", "Zep Community Edition", "getzep", "https://github.com/getzep/zep", "Apache-2.0", ("https://github.com/getzep/zep",), "Compare self-hosted memory semantics without claiming parity or importing implementation code."),
+
+    # Multimodal & vision
+    _project("qwen3-vl", "multimodal_vision", "Qwen3-VL", "QwenLM", "https://github.com/QwenLM/Qwen3-VL", "Apache-2.0", ("https://github.com/QwenLM/Qwen3-VL",), "Gate image and document observations as cited evidence, never as unqualified ground truth."),
+    _project("glm-v", "multimodal_vision", "GLM-V / GLM-4.5V", "zai-org", "https://github.com/zai-org/GLM-V", "MIT", ("https://arxiv.org/abs/2507.01006",), "Study multimodal reasoning with modality-specific confidence and redaction before retention."),
+    _project("internvl", "multimodal_vision", "InternVL", "OpenGVLab", "https://github.com/OpenGVLab/InternVL", "MIT", ("https://arxiv.org/abs/2312.14238",), "Evaluate open multimodal checkpoints through a reproducible visual task harness."),
+    _project("janus", "multimodal_vision", "Janus", "deepseek-ai", "https://github.com/deepseek-ai/Janus", "MIT", ("https://arxiv.org/abs/2410.13848",), "Separate understanding and generation evidence paths in A11oy receipts."),
+    _project("minicpm-o", "multimodal_vision", "MiniCPM-o", "OpenBMB", "https://github.com/OpenBMB/MiniCPM-o", "UNKNOWN", ("https://github.com/OpenBMB/MiniCPM-o",), "Probe laptop-feasible multimodal inference with measured latency and explicit modality limits."),
+
+    # Biomed & science
+    _project("gpt-oss", "biomed_science", "gpt-oss", "openai", "https://github.com/openai/gpt-oss", "Apache-2.0", ("https://github.com/openai/gpt-oss",), "Evaluate scientific reasoning only on cited corpora with domain-expert review required."),
+    _project("glm-4-5v-science", "biomed_science", "GLM-4.5V", "zai-org", "https://github.com/zai-org/GLM-V", "MIT", ("https://arxiv.org/abs/2507.01006",), "Test chart and document understanding without upgrading it to clinical validity."),
+    _project("deepseek-r1-science", "biomed_science", "DeepSeek-R1", "deepseek-ai", "https://github.com/deepseek-ai/DeepSeek-R1", "MIT", ("https://arxiv.org/abs/2501.12948",), "Run scientific derivations through unit, citation, and formal-invariant checks."),
+    _project("openmed", "biomed_science", "OpenMed", "maziyarpanahi", "https://github.com/maziyarpanahi/openmed", "Apache-2.0", ("https://arxiv.org/abs/2508.01630",), "Study local clinical NLP with privacy boundaries; outputs remain non-diagnostic and review-gated."),
+    _project("physicsnemo", "biomed_science", "PhysicsNeMo", "NVIDIA", "https://github.com/NVIDIA/physicsnemo", "Apache-2.0", ("https://github.com/NVIDIA/physicsnemo/tree/main/docs",), "Map physics residuals into the existing A11oy formula and evidence gates."),
+
+    # Security & red-team
+    _project("garak", "security_red_team", "garak", "NVIDIA", "https://github.com/NVIDIA/garak", "Apache-2.0", ("https://github.com/NVIDIA/garak/tree/main/docs",), "Translate probe outcomes into deny-by-default test evidence, not a blanket safety claim."),
+    _project("pyrit", "security_red_team", "PyRIT", "Azure", "https://github.com/Azure/PyRIT", "MIT", ("https://github.com/Azure/PyRIT/tree/main/doc",), "Adapt orchestrated red-team cases to governed, rate-limited A11oy evaluation runs."),
+    _project("owasp-genai-top10", "security_red_team", "OWASP Top 10 for LLM Applications", "OWASP", "https://github.com/OWASP/www-project-top-10-for-large-language-model-applications", "CC-BY-SA-4.0", ("https://genai.owasp.org/llm-top-10/",), "Crosswalk each risk category to enforceable gates and evidence-bearing tests."),
+    _project("promptfoo", "security_red_team", "promptfoo", "promptfoo", "https://github.com/promptfoo/promptfoo", "MIT", ("https://github.com/promptfoo/promptfoo/tree/main/site/docs",), "Study declarative adversarial evaluations while keeping A11oy policy decisions local."),
+    _project("llm-guard", "security_red_team", "LLM Guard", "ProtectAI", "https://github.com/protectai/llm-guard", "MIT", ("https://github.com/protectai/llm-guard/tree/main/docs",), "Compare input/output scanners as advisory signals under the constitutional gate."),
+
+    # Datasets & curation
+    _project("hf-datasets", "datasets_curation", "Datasets", "huggingface", "https://github.com/huggingface/datasets", "Apache-2.0", ("https://github.com/huggingface/datasets/tree/main/docs",), "Record dataset revisions, configuration, splits, and source licenses in ingestion receipts."),
+    _project("kagglehub", "datasets_curation", "KaggleHub", "Kaggle", "https://github.com/Kaggle/kagglehub", "Apache-2.0", ("https://github.com/Kaggle/kagglehub",), "Resolve assets into a quarantined cache with checksums and explicit terms review."),
+    _project("openml-python", "datasets_curation", "OpenML Python", "openml", "https://github.com/openml/openml-python", "BSD-3-Clause", ("https://github.com/openml/openml-python/tree/main/doc",), "Preserve task and dataset identifiers so experiments can be replayed exactly."),
+    _project("croissant", "datasets_curation", "Croissant", "mlcommons", "https://github.com/mlcommons/croissant", "Apache-2.0", ("https://docs.mlcommons.org/croissant/docs/croissant-spec.html",), "Emit Croissant-compatible metadata alongside A11oy provenance without replacing receipts."),
+    _project("datatrove", "datasets_curation", "DataTrove", "huggingface", "https://github.com/huggingface/datatrove", "Apache-2.0", ("https://github.com/huggingface/datatrove/tree/main/docs",), "Study scalable filtering with auditable rejection reasons and reversible curation manifests."),
+
+    # Sovereign / on-metal serving
+    _project("vllm-serving", "sovereign_on_metal_serving", "vLLM", "vllm-project", "https://github.com/vllm-project/vllm", "Apache-2.0", ("https://github.com/vllm-project/vllm/tree/main/docs",), "Run only profiles admitted by real VRAM, driver, and model-license probes."),
+    _project("ollama", "sovereign_on_metal_serving", "Ollama", "ollama", "https://github.com/ollama/ollama", "MIT", ("https://github.com/ollama/ollama/tree/main/docs",), "Use a loopback-only local backend with explicit model digests and bounded concurrency."),
+    _project("llama-cpp-serving", "sovereign_on_metal_serving", "llama.cpp", "ggml-org", "https://github.com/ggml-org/llama.cpp", "MIT", ("https://github.com/ggml-org/llama.cpp/tree/master/examples/server",), "Adapt the local server behind A11oy authentication, quotas, and receipt-on-write rules."),
+    _project("sglang-serving", "sovereign_on_metal_serving", "SGLang", "sgl-project", "https://github.com/sgl-project/sglang", "Apache-2.0", ("https://github.com/sgl-project/sglang/tree/main/docs",), "Study high-throughput local serving with isolation and honest capacity reporting."),
+    _project("kserve", "sovereign_on_metal_serving", "KServe", "kserve", "https://github.com/kserve/kserve", "Apache-2.0", ("https://github.com/kserve/website/tree/main/docs",), "Map portable serving declarations to signed deployment policy and rollback evidence."),
+
+    # Verifiable orchestration & provenance
+    _project("risc0", "verifiable_orchestration_provenance", "RISC Zero zkVM", "risc0", "https://github.com/risc0/risc0", "Apache-2.0 OR MIT", ("https://dev.risczero.com/proof-system-in-detail.pdf",), "Explore bounded proof adapters while labeling unproved A11oy paths as unavailable."),
+    _project("rekor", "verifiable_orchestration_provenance", "Rekor", "sigstore", "https://github.com/sigstore/rekor", "Apache-2.0", ("https://github.com/sigstore/rekor/tree/main/docs",), "Anchor selected receipt digests to transparency evidence without signing on reads."),
+    _project("in-toto", "verifiable_orchestration_provenance", "in-toto", "in-toto", "https://github.com/in-toto/in-toto", "Apache-2.0", ("https://github.com/in-toto/docs",), "Map A11oy action receipts to supply-chain step attestations with verified identities."),
+    _project("slsa", "verifiable_orchestration_provenance", "SLSA", "slsa-framework", "https://github.com/slsa-framework/slsa", "Apache-2.0", ("https://slsa.dev/spec/v1.2/",), "Use SLSA levels as externally defined criteria, never as a self-awarded badge."),
+    _project("ezkl", "verifiable_orchestration_provenance", "EZKL", "zkonduit", "https://github.com/zkonduit/ezkl", "MIT", ("https://github.com/zkonduit/ezkl/tree/main/docs",), "Prototype proof-carrying small-model inference and report unsupported operators honestly."),
+    _project("opengradient", "verifiable_orchestration_provenance", "OpenGradient SDK", "OpenGradient", "https://github.com/OpenGradient/sdk", "UNKNOWN", ("https://github.com/OpenGradient/sdk/tree/main/docs",), "Study externally verifiable execution receipts without treating third-party claims as local proof."),
+
+    # Formal proof & training
+    _project("lean4", "formal_proof_training", "Lean 4", "leanprover", "https://github.com/leanprover/lean4", "Apache-2.0", ("https://github.com/leanprover/lean4/tree/master/doc",), "Keep runtime formula claims linked to checked theorem names and exact proof revisions."),
+    _project("mathlib4", "formal_proof_training", "mathlib4", "leanprover-community", "https://github.com/leanprover-community/mathlib4", "Apache-2.0", ("https://github.com/leanprover-community/mathlib4/tree/master/Mathlib",), "Study reusable lemmas while maintaining A11oy theorem ownership and dependency manifests."),
+    _project("trl", "formal_proof_training", "TRL", "huggingface", "https://github.com/huggingface/trl", "Apache-2.0", ("https://github.com/huggingface/trl/tree/main/docs",), "Run post-training experiments as versioned recipes with baseline, seed, and evaluation receipts."),
+    _project("peft", "formal_proof_training", "PEFT", "huggingface", "https://github.com/huggingface/peft", "Apache-2.0", ("https://github.com/huggingface/peft/tree/main/docs",), "Prefer laptop-feasible adapters and record base-model plus adapter revisions independently."),
+    _project("unsloth", "formal_proof_training", "Unsloth", "unslothai", "https://github.com/unslothai/unsloth", "Apache-2.0", ("https://github.com/unslothai/unsloth/tree/main/docs",), "Study memory-efficient fine-tuning only after a hardware probe selects a safe recipe."),
+)
+
+
+_REPO_PATH = re.compile(r"^/[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+/?$")
+_CACHE: Dict[str, Tuple[float, Mapping[str, Any]]] = {}
+_CACHE_LOCK = threading.RLock()
+
+
+def _repo_slug(repo_url: str) -> str:
+    parsed = urlparse(repo_url)
+    if parsed.scheme != "https" or parsed.netloc.lower() != "github.com":
+        raise ValueError("canonical_repo_url must be an https://github.com owner/repo URL")
+    if parsed.query or parsed.fragment or not _REPO_PATH.fullmatch(parsed.path):
+        raise ValueError("canonical_repo_url must not contain a subpath, query, or fragment")
+    owner, repo = parsed.path.strip("/").split("/", 1)
+    if repo.lower().endswith(".git"):
+        repo = repo[:-4]
+    return f"{owner}/{repo}"
+
+
+def _iso_utc(epoch_s: float) -> str:
+    return datetime.fromtimestamp(epoch_s, timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _safe_reason(exc: BaseException) -> str:
+    text = " ".join(str(exc).split()) or exc.__class__.__name__
+    return text[:240]
+
+
+def _unavailable(repo_url: str, reason: str) -> Dict[str, Any]:
+    return {
+        "label": UNAVAILABLE,
+        "freshness": UNAVAILABLE,
+        "source": "GitHub REST API",
+        "source_url": f"https://api.github.com/repos/{_repo_slug(repo_url)}",
+        "stars": None,
+        "stars_label": UNAVAILABLE,
+        "license": None,
+        "license_label": UNAVAILABLE,
+        "revision": None,
+        "revision_label": UNAVAILABLE,
+        "default_branch": None,
+        "fetched_at": None,
+        "fetched_at_label": UNAVAILABLE,
+        "reason": reason,
+    }
+
+
+def _request_headers() -> Dict[str, str]:
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "a11oy-primary-project-registry/1.0",
+    }
+    token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def _read_json(url: str, timeout_s: float, opener: Callable[..., Any]) -> Mapping[str, Any]:
+    request = Request(url, headers=_request_headers(), method="GET")
+    response = opener(request, timeout=timeout_s)
+    try:
+        raw = response.read(MAX_RESPONSE_BYTES + 1)
+    finally:
+        close = getattr(response, "close", None)
+        if callable(close):
+            close()
+    if len(raw) > MAX_RESPONSE_BYTES:
+        raise ValueError("GitHub response exceeded the bounded response size")
+    payload = json.loads(raw.decode("utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("GitHub response was not a JSON object")
+    return payload
+
+
+def clear_cache() -> None:
+    """Clear only the in-memory live-metadata cache (primarily for tests)."""
+    with _CACHE_LOCK:
+        _CACHE.clear()
+
+
+def fetch_github_metadata(
+    repo_url: str,
+    *,
+    timeout_s: float = DEFAULT_TIMEOUT_S,
+    ttl_s: float = DEFAULT_TTL_S,
+    opener: Optional[Callable[..., Any]] = None,
+    now: Optional[float] = None,
+) -> Dict[str, Any]:
+    """Fetch stars, SPDX license, and the default-branch commit revision.
+
+    ``opener`` is injectable for deterministic tests and must follow the small
+    ``urllib.request.urlopen(request, timeout=...)`` interface.  A cache entry is
+    used only while it is inside ``ttl_s``.  Any fetch/parse/shape failure returns
+    an ``UNAVAILABLE`` envelope with null live values.
+    """
+    slug = _repo_slug(repo_url)
+    if not isinstance(timeout_s, (int, float)) or not 0 < float(timeout_s) <= 30.0:
+        raise ValueError("timeout_s must be in (0, 30]")
+    if not isinstance(ttl_s, (int, float)) or float(ttl_s) < 0:
+        raise ValueError("ttl_s must be non-negative")
+    current = time.time() if now is None else float(now)
+
+    with _CACHE_LOCK:
+        cached = _CACHE.get(slug)
+        if cached and current - cached[0] < float(ttl_s):
+            result = deepcopy(cached[1])
+            result["freshness"] = "CACHE_FRESH"
+            result["cache_age_s"] = round(max(0.0, current - cached[0]), 3)
+            return result
+
+    open_url = urlopen if opener is None else opener
+    repo_api = f"https://api.github.com/repos/{slug}"
+    try:
+        repo_payload = _read_json(repo_api, float(timeout_s), open_url)
+        stars = repo_payload.get("stargazers_count")
+        branch = repo_payload.get("default_branch")
+        if isinstance(stars, bool) or not isinstance(stars, int) or stars < 0:
+            raise ValueError("GitHub stargazers_count was missing or invalid")
+        if not isinstance(branch, str) or not branch.strip():
+            raise ValueError("GitHub default_branch was missing or invalid")
+
+        commit_api = f"{repo_api}/commits/{quote(branch, safe='')}"
+        commit_payload = _read_json(commit_api, float(timeout_s), open_url)
+        revision = commit_payload.get("sha")
+        if not isinstance(revision, str) or not re.fullmatch(r"[0-9a-fA-F]{40}", revision):
+            raise ValueError("GitHub commit sha was missing or invalid")
+
+        license_obj = repo_payload.get("license")
+        spdx = license_obj.get("spdx_id") if isinstance(license_obj, dict) else None
+        if not isinstance(spdx, str) or not spdx or spdx == "NOASSERTION":
+            spdx = None
+        result: Dict[str, Any] = {
+            "label": LIVE_LABEL,
+            "freshness": "LIVE",
+            "source": "GitHub REST API",
+            "source_url": repo_api,
+            "stars": stars,
+            "stars_label": LIVE_LABEL,
+            "license": spdx,
+            "license_label": LIVE_LABEL if spdx else UNAVAILABLE,
+            "revision": revision.lower(),
+            "revision_label": LIVE_LABEL,
+            "default_branch": branch,
+            "fetched_at": _iso_utc(current),
+            "fetched_at_label": LIVE_LABEL,
+            "reason": None,
+        }
+    except Exception as exc:  # urllib, timeout, decoding, and schema failures
+        return _unavailable(repo_url, f"live GitHub metadata unavailable: {_safe_reason(exc)}")
+
+    with _CACHE_LOCK:
+        _CACHE[slug] = (current, deepcopy(result))
+    return deepcopy(result)
+
+
+def projects() -> List[Dict[str, Any]]:
+    """Return a caller-owned copy of the unranked static registry."""
+    return deepcopy(list(_PROJECTS))
+
+
+def info() -> Dict[str, Any]:
+    """Return a deterministic, JSON-ready description of this registry."""
+    counts = {field["id"]: 0 for field in _FIELDS}
+    for item in _PROJECTS:
+        counts[item["field"]] += 1
+    fields = [
+        {"id": field["id"], "name": field["name"], "project_count": counts[field["id"]]}
+        for field in _FIELDS
+    ]
+    return {
+        "ok": True,
+        "service": "a11oy.primary_project_registry",
+        "version": REGISTRY_VERSION,
+        "label": STATIC_LABEL,
+        "attribution": ATTRIBUTION,
+        "ranking": "NONE",
+        "scope": "projects_and_organizations_only",
+        "source_policy": "primary official GitHub, standards, and paper URLs only",
+        "license_policy": "license_expected is static guidance; live license is reported beside a fetched revision",
+        "live_metadata_policy": "never hand-typed; explicit fetch, bounded timeout, TTL cache, UNAVAILABLE on failure",
+        "field_count": len(_FIELDS),
+        "project_count": len(_PROJECTS),
+        "fields": fields,
+    }
+
+
+def _field_selection(fields: Optional[Iterable[str]]) -> Tuple[str, ...]:
+    allowed = tuple(field["id"] for field in _FIELDS)
+    if fields is None:
+        return allowed
+    requested = tuple(dict.fromkeys(fields))
+    unknown = sorted(set(requested) - set(allowed))
+    if unknown:
+        raise ValueError(f"unknown field id(s): {', '.join(unknown)}")
+    return requested
+
+
+def snapshot(
+    *,
+    fetch_live: bool = False,
+    fields: Optional[Iterable[str]] = None,
+    timeout_s: float = DEFAULT_TIMEOUT_S,
+    ttl_s: float = DEFAULT_TTL_S,
+    max_workers: int = 5,
+    opener: Optional[Callable[..., Any]] = None,
+    now: Optional[float] = None,
+) -> Dict[str, Any]:
+    """Return a JSON-ready registry snapshot; performs no network I/O by default.
+
+    With ``fetch_live=True``, unique repositories are fetched concurrently and
+    results are mapped back to every field entry.  Duplicate cross-field projects
+    therefore share one revision-bound observation.  This function registers no
+    HTTP route; a caller may expose the returned payload separately.
+    """
+    selected = set(_field_selection(fields))
+    items = [deepcopy(dict(item)) for item in _PROJECTS if item["field"] in selected]
+
+    if not fetch_live:
+        for item in items:
+            item["live_metadata"] = _unavailable(
+                item["canonical_repo_url"],
+                "live fetch disabled; static registry only",
+            )
+        payload = info()
+        payload.update({
+            "live_metadata_requested": False,
+            "live_metadata_summary": {LIVE_LABEL: 0, UNAVAILABLE: len(items)},
+            "selected_fields": [field["id"] for field in _FIELDS if field["id"] in selected],
+            "snapshot_project_count": len(items),
+            "unique_repository_count": len({item["canonical_repo_url"] for item in items}),
+            "projects": items,
+        })
+        return payload
+
+    if not isinstance(max_workers, int) or not 1 <= max_workers <= 16:
+        raise ValueError("max_workers must be in [1, 16]")
+    unique_repos = tuple(dict.fromkeys(item["canonical_repo_url"] for item in items))
+    metadata: Dict[str, Mapping[str, Any]] = {}
+
+    def fetch(repo_url: str) -> Mapping[str, Any]:
+        return fetch_github_metadata(
+            repo_url,
+            timeout_s=timeout_s,
+            ttl_s=ttl_s,
+            opener=opener,
+            now=now,
+        )
+
+    with ThreadPoolExecutor(max_workers=min(max_workers, max(1, len(unique_repos)))) as pool:
+        futures = {pool.submit(fetch, repo): repo for repo in unique_repos}
+        for future in as_completed(futures):
+            repo = futures[future]
+            try:
+                metadata[repo] = future.result()
+            except Exception as exc:  # defensive: one project must not abort the snapshot
+                metadata[repo] = _unavailable(repo, f"live metadata worker unavailable: {_safe_reason(exc)}")
+
+    counts = {LIVE_LABEL: 0, UNAVAILABLE: 0}
+    for item in items:
+        observed = deepcopy(metadata[item["canonical_repo_url"]])
+        item["live_metadata"] = observed
+        counts[observed["label"] if observed["label"] == LIVE_LABEL else UNAVAILABLE] += 1
+    payload = info()
+    payload.update({
+        "live_metadata_requested": True,
+        "live_metadata_summary": counts,
+        "selected_fields": [field["id"] for field in _FIELDS if field["id"] in selected],
+        "snapshot_project_count": len(items),
+        "unique_repository_count": len(unique_repos),
+        "projects": items,
+    })
+    return payload
+
+
+__all__ = [
+    "ATTRIBUTION",
+    "DEFAULT_TIMEOUT_S",
+    "DEFAULT_TTL_S",
+    "LIVE_LABEL",
+    "REGISTRY_VERSION",
+    "STATIC_LABEL",
+    "UNAVAILABLE",
+    "clear_cache",
+    "fetch_github_metadata",
+    "info",
+    "projects",
+    "snapshot",
+]

serve.py

@@ -101,7 +101,119 @@ except ImportError:
 # --- end OTel preamble ---
 
 
-app = FastAPI(title="a11oy — Brand Orchestration Layer", version="2.0.0")
+# The implicit FastAPI /openapi.json route calls app.openapi() without the
+# defensive per-route fallback used by our backend hardening. On the assembled
+# app one malformed legacy annotation could therefore make the conventional
+# schema path return 500 while the curated schema remained healthy. Disable the
+# implicit docs routes; szl_be_hardening registers both the canonical
+# /api/a11oy/openapi.json and an exact /openapi.json alias from one builder.
+app = FastAPI(
+    title="a11oy — Brand Orchestration Layer",
+    version="2.0.0",
+    openapi_url=None,
+    docs_url=None,
+    redoc_url=None,
+)
+
+# Waqay Security Loop (wave 15): expose only the deterministic, read-only
+# contract.  The implementation has no deployment, recall, repository, signing,
+# model, or other external effector.  Mutation endpoints stay deliberately
+# absent until identity, policy, approval, provenance, and direct-origin bypass
+# controls are independently verified.
+try:
+    from szl_waqay_security_loop import security_loop_manifest
+    _WAQAY_SECURITY_LOOP_READY = True
+except Exception:  # pragma: no cover - honest optional degradation
+    security_loop_manifest = None  # type: ignore[assignment]
+    _WAQAY_SECURITY_LOOP_READY = False
+
+
+@app.get("/api/a11oy/v1/waqay/security-loop/manifest")
+async def waqay_security_loop_manifest() -> JSONResponse:
+    if not _WAQAY_SECURITY_LOOP_READY or security_loop_manifest is None:
+        return JSONResponse(
+            {
+                "ready": False,
+                "mode": "UNAVAILABLE",
+                "effectors": 0,
+                "external_mutations": "DISABLED",
+            },
+            status_code=503,
+        )
+    return JSONResponse({"ready": True, **security_loop_manifest()})
+
+
+# Claim Rupture Gate (wave 15): contract-only exposure.  The module consumes
+# externally supplied uncertainty/factuality evidence but never invents a score,
+# upgrades a claim, persists a decision, or invokes an effector.  Evaluation
+# POST routes remain absent pending identity/policy/abuse review.
+try:
+    from szl_claim_rupture_gate import info as claim_rupture_gate_info
+    _CLAIM_RUPTURE_GATE_READY = True
+except Exception:  # pragma: no cover - honest optional degradation
+    claim_rupture_gate_info = None  # type: ignore[assignment]
+    _CLAIM_RUPTURE_GATE_READY = False
+
+
+@app.get("/api/a11oy/v1/claim-integrity/info")
+async def claim_integrity_info() -> JSONResponse:
+    if not _CLAIM_RUPTURE_GATE_READY or claim_rupture_gate_info is None:
+        return JSONResponse(
+            {
+                "ready": False,
+                "decision_state": "UNAVAILABLE",
+                "effectors_enabled": 0,
+            },
+            status_code=503,
+        )
+    return JSONResponse({"ready": True, **claim_rupture_gate_info()})
+
+
+# Primary-project registry (wave 15): primary sources, projects/organizations
+# rather than editorial rankings of people.  The public endpoints intentionally
+# serve the deterministic registry only; anonymous GitHub refreshes stay out of
+# the request path to avoid rate-limit and availability claims.
+try:
+    from research.a11oy_primary_project_registry import (
+        info as primary_project_registry_info,
+        snapshot as primary_project_registry_snapshot,
+    )
+    _PRIMARY_PROJECT_REGISTRY_READY = True
+except Exception:  # pragma: no cover - honest optional degradation
+    primary_project_registry_info = None  # type: ignore[assignment]
+    primary_project_registry_snapshot = None  # type: ignore[assignment]
+    _PRIMARY_PROJECT_REGISTRY_READY = False
+
+
+@app.get("/api/a11oy/v1/frontier/projects/info")
+async def frontier_projects_info() -> JSONResponse:
+    if not _PRIMARY_PROJECT_REGISTRY_READY or primary_project_registry_info is None:
+        return JSONResponse({"ok": False, "label": "UNAVAILABLE"}, status_code=503)
+    return JSONResponse(primary_project_registry_info())
+
+
+@app.get("/api/a11oy/v1/frontier/projects")
+async def frontier_projects_snapshot() -> JSONResponse:
+    if not _PRIMARY_PROJECT_REGISTRY_READY or primary_project_registry_snapshot is None:
+        return JSONResponse({"ok": False, "label": "UNAVAILABLE"}, status_code=503)
+    return JSONResponse(primary_project_registry_snapshot(fetch_live=False))
+
+
+def _optional_module_absent(exc: Exception, module: str, surface: str,
+                            *, stream=None) -> bool:
+    """Log a direct optional-module absence without a noisy traceback.
+
+    Missing transitive dependencies and registration errors deliberately return
+    False: those are defects and callers must retain their diagnostic traceback.
+    """
+    if isinstance(exc, ModuleNotFoundError) and getattr(exc, "name", None) == module:
+        print(
+            f"[a11oy] OPTIONAL-ABSENT {module}: {surface} not registered; "
+            "existing routes unaffected",
+            file=stream or sys.stderr,
+        )
+        return True
+    return False
 
 # ── Shared guarded-surface wrapper (Wave R Dev 2) — one bad surface must NEVER 500 the
 # SPA. This ASGI middleware converts an unhandled exception from any JSON API surface
@@ -216,19 +328,20 @@ except Exception as _szl_bh_e:  # pragma: no cover
 # fail-open (tracing NEVER breaks a request); locked=8; Λ=Conjecture 1; no key.
 try:
     import szl_observability as _szl_observability
-    _szl_observability.register(app, ns="a11oy")
-    # -- ADDITIVE (free-first spend guardrail) -- szl_spend_cap
-    try:
-        import szl_spend_cap as _szl_spend_cap
-        print("[a11oy] " + _szl_spend_cap.register(app, ns="a11oy"), file=__import__("sys").stderr)
-    except Exception as _szl_spend_cap_e:
-        print(f"[szl_spend_cap] NOT mounted ({_szl_spend_cap_e!r}); existing routes unaffected", file=__import__("sys").stderr)
-    # -- ADDITIVE (free-first spend guardrail) -- szl_spend_cap end
-    print("[a11oy] Observability registered: /api/a11oy/v1/observability/{traces,trace/{id},health-summary} (OpenTelemetry-style tracing, stdlib)", file=__import__("sys").stderr)
+    _szl_obs_paths = _szl_observability.register(app, ns="a11oy")
+    print(f"[a11oy] Observability registered once: {_szl_obs_paths}", file=sys.stderr)
 except Exception as _szl_obs_e:  # pragma: no cover
-    print(f"[a11oy] Observability NOT registered: {_szl_obs_e!r}; existing routes unaffected", file=__import__("sys").stderr)
+    print(f"[a11oy] Observability NOT registered: {_szl_obs_e!r}; existing routes unaffected", file=sys.stderr)
 # ── Observability / distributed tracing (devN) — szl_observability ── end
 
+# The spend cap is independent of tracing. An optional observability failure must
+# never decide whether the free-first guardrail is present.
+try:
+    import szl_spend_cap as _szl_spend_cap
+    print("[a11oy] " + _szl_spend_cap.register(app, ns="a11oy"), file=sys.stderr)
+except Exception as _szl_spend_cap_e:
+    print(f"[szl_spend_cap] NOT mounted ({_szl_spend_cap_e!r}); existing routes unaffected", file=sys.stderr)
+
 # ── Resilience (devM) — szl_resilience ──
 # ADDITIVE on top of backend-hardening (#346) + prod-hardening (#345). Two proven
 # patterns, our own implementation: (1) a Hystrix-style CIRCUIT BREAKER that wraps
@@ -2886,8 +2999,10 @@ try:
     print(f"[a11oy] /about/thesis registered: {_thesis_status}", file=_sys_th.stderr)
 except Exception as _th_e:
     import sys as _sys_th, traceback as _tb_th
-    print(f"[a11oy] /about/thesis NOT registered: {_th_e}", file=_sys_th.stderr)
-    _tb_th.print_exc()
+    if not _optional_module_absent(_th_e, "szl_thesis_about", "/about/thesis",
+                                   stream=_sys_th.stderr):
+        print(f"[a11oy] /about/thesis NOT registered: {_th_e}", file=_sys_th.stderr)
+        _tb_th.print_exc()
 # ── end /about/thesis ────────────────────────────────────────────────────────
 
 # ── Provenance Hardening (Yachay / Doctrine v12) — ADDITIVE, registered EARLY ──
@@ -3309,7 +3424,9 @@ try:
     app.include_router(_formulas_mod.router)
     print("[a11oy] SZL_FORMULA_OPS mounted: 8x POST /formulas/<name> + /formulas-ops (UI) + /api/a11oy/v1/formulas-ops (index)", file=sys.stderr)
 except Exception as _formulas_exc:  # additive: never break the Space if the module is absent
-    print(f"[a11oy] FORMULAS mount skipped: {_formulas_exc}", file=sys.stderr)
+    if not _optional_module_absent(
+            _formulas_exc, "szl_formula_ops", "Formula Operationalizer"):
+        print(f"[a11oy] FORMULAS mount failed: {_formulas_exc}", file=sys.stderr)
 
 # ---------------------------------------------------------------------------
 # ADDITIVE (Yachay / Doctrine v12 PURIQ): mount the a11oy.code conversational
@@ -3870,8 +3987,10 @@ try:
     print(f"[a11oy] v4 PAC-Bayes Predict registered: {_v4_predict_status}", file=_v4p_sys.stderr)
 except Exception as _v4p_e:
     import sys as _v4p_sys, traceback as _v4p_tb
-    print(f"[a11oy] v4 PAC-Bayes Predict NOT registered: {_v4p_e!r}", file=_v4p_sys.stderr)
-    _v4p_tb.print_exc()
+    if not _optional_module_absent(_v4p_e, "a11oy_v4_predict", "v4 PAC-Bayes Predict",
+                                   stream=_v4p_sys.stderr):
+        print(f"[a11oy] v4 PAC-Bayes Predict NOT registered: {_v4p_e!r}", file=_v4p_sys.stderr)
+        _v4p_tb.print_exc()
 
 try:
     import a11oy_v4_thesis_primitives as _v4_tp
@@ -3880,8 +3999,11 @@ try:
     print(f"[a11oy] v4 Thesis Primitives registered: {_v4_tp_status}", file=_v4tp_sys.stderr)
 except Exception as _v4tp_e:
     import sys as _v4tp_sys, traceback as _v4tp_tb
-    print(f"[a11oy] v4 Thesis Primitives NOT registered: {_v4tp_e!r}", file=_v4tp_sys.stderr)
-    _v4tp_tb.print_exc()
+    if not _optional_module_absent(
+            _v4tp_e, "a11oy_v4_thesis_primitives", "v4 Thesis Primitives",
+            stream=_v4tp_sys.stderr):
+        print(f"[a11oy] v4 Thesis Primitives NOT registered: {_v4tp_e!r}", file=_v4tp_sys.stderr)
+        _v4tp_tb.print_exc()
 # --- end PAC-Bayes Predict + Thesis Primitives ---
 
 
@@ -4918,29 +5040,11 @@ except Exception as _sc_e:  # pragma: no cover
     print(f"[a11oy] szl_sovereign_compute NOT registered ({_sc_e!r}); existing routes unaffected", file=sys.stderr)
 
 
-# ===========================================================================
-# a11oy OBSERVABILITY (ADDITIVE, 2026-06-01, Yachay / Perplexity Computer Agent).
-# Business observability instilled as a NATIVE a11oy capability — NOT a separate
-# product, NOT an add-on, NOT a separate brand. a11oy is the platform; observability
-# is one of its endpoints. szl_observability.register(app, ns="a11oy") adds, under
-# /api/a11oy/v3/observability/* : manifesto, pillars (9), pillars/{name}, tag,
-# attribute-revenue, query (Honeycomb-style), compliance/{framework}, decision-replay,
-# and a mobile-first /dashboard. Reads the REAL in-process organs (Wire D Khipu DAG
-# via app.state.szl_emit_signed_receipt / szl_khipu_dag, trace state) — a pillar with
-# no wired source honestly reports status="unknown" (never faked). Registered BEFORE
-# the /api/a11oy/{path:path} Node proxy + SPA catch-all so /api/a11oy/v3/observability/*
-# resolve LOCALLY. try/except-guarded: can NEVER take down a route.
-# DIFFERENTIATOR: the only observability stack that signs every event (Wire D DSSE),
-# proves the chain via Lean (749/14/163), and replays decisions years later (AYNI-OS).
-# LOCKED preserved: Doctrine v11 749/14/163, 13-axis, SLSA L1, Λ-uniqueness=Conjecture 1.
-# ---------------------------------------------------------------------------
-try:
-    import szl_observability as _obs
-    _obs_info = _obs.register(app, ns="a11oy")
-    print(f"[szl_observability] a11oy observability mounted: base={_obs_info.get('base')}, "
-          f"pillars={_obs_info.get('pillars')}, slsa={_obs_info.get('slsa')}", file=sys.stderr)
-except Exception as _obs_e:  # pragma: no cover - defensive, additive-only
-    print(f"[szl_observability] a11oy observability NOT mounted ({_obs_e!r}); existing routes unaffected", file=sys.stderr)
+# Observability is registered exactly once near app construction. A historical
+# duplicate lived here and expected a dict even though register() returns
+# list[str], producing a false startup error after the routes were already live.
+# Keep one authoritative v1 tracing contract; the stale, nonexistent v3 claims
+# are intentionally removed rather than preserved as dead documentation.
 
 
 # ===========================================================================
@@ -5129,8 +5233,9 @@ try:
     print("[a11oy] szl_kernels_organ: 9 living kernels at /api/a11oy/v3/kernels/*", file=sys.stderr)
 except Exception as _ke:
     import traceback as _tb_k
-    print(f"[a11oy] szl_kernels_organ NOT registered: {_ke}", file=sys.stderr)
-    _tb_k.print_exc()
+    if not _optional_module_absent(_ke, "szl_kernels_organ", "agentic Codex kernels"):
+        print(f"[a11oy] szl_kernels_organ NOT registered: {_ke}", file=sys.stderr)
+        _tb_k.print_exc()
 
 
 # ---------------------------------------------------------------------------
@@ -5225,8 +5330,9 @@ try:
     print(f"[a11oy] Typed Ontology + Object Explorer registered: {_ont_status}", file=sys.stderr)
 except Exception as _ont_e:
     import traceback as _ont_tb
-    print(f"[a11oy] Typed Ontology NOT registered: {_ont_e!r}", file=sys.stderr)
-    _ont_tb.print_exc(file=sys.stderr)
+    if not _optional_module_absent(_ont_e, "a11oy_ontology", "Typed Ontology"):
+        print(f"[a11oy] Typed Ontology NOT registered: {_ont_e!r}", file=sys.stderr)
+        _ont_tb.print_exc(file=sys.stderr)
 
 # C. Derivation DAG renderer (/api/a11oy/v4/derivation/{id}, /derivation/{id}, vendored Three.js)
 try:
@@ -5235,8 +5341,9 @@ try:
     print(f"[a11oy] Derivation DAG renderer registered: {_deriv_status}", file=sys.stderr)
 except Exception as _deriv_e:
     import traceback as _deriv_tb
-    print(f"[a11oy] Derivation DAG NOT registered: {_deriv_e!r}", file=sys.stderr)
-    _deriv_tb.print_exc(file=sys.stderr)
+    if not _optional_module_absent(_deriv_e, "a11oy_derivation", "Derivation DAG"):
+        print(f"[a11oy] Derivation DAG NOT registered: {_deriv_e!r}", file=sys.stderr)
+        _deriv_tb.print_exc(file=sys.stderr)
 
 # B. Synchronized 4-lens shell (/explorer)
 try:
@@ -5245,8 +5352,9 @@ try:
     print(f"[a11oy] 4-lens synchronized Explorer registered: {_explorer_status}", file=sys.stderr)
 except Exception as _explorer_e:
     import traceback as _explorer_tb
-    print(f"[a11oy] 4-lens Explorer NOT registered: {_explorer_e!r}", file=sys.stderr)
-    _explorer_tb.print_exc(file=sys.stderr)
+    if not _optional_module_absent(_explorer_e, "a11oy_explorer", "4-lens Explorer"):
+        print(f"[a11oy] 4-lens Explorer NOT registered: {_explorer_e!r}", file=sys.stderr)
+        _explorer_tb.print_exc(file=sys.stderr)
 
 # Every /agent/ask and /predict call writes the full Worker->Critic->Yuyay-13->Lambda->
 # Khipu derivation chain into the Khipu (Receipt) store as a graph (Palantir AIP Logic
@@ -10062,7 +10170,13 @@ async def api_proxy(request: Request, path: str) -> Response:
 # ===========================================================================
 try:
     from fastapi.responses import Response as _VendResponse
+    # Resolve from the image root in production and from this checkout during
+    # local operator verification.  The previous image-only path made the
+    # injected operator widget 404 on every local HTML page even though the
+    # vendored asset was present in ``static-vendor/``.
     _VENDOR_DIR = Path("/app/static-vendor")
+    if not _VENDOR_DIR.is_dir():
+        _VENDOR_DIR = Path(__file__).resolve().parent / "static-vendor"
     _VENDOR_JS_CT = "application/javascript; charset=utf-8"
     _VENDOR_CSS_CT = "text/css; charset=utf-8"
     # Allowlist of the 7 keepers + KaTeX (exact filenames the console references).
@@ -10255,6 +10369,14 @@ except Exception as _opw_e:  # never crash the app — additive only
 # ---------------------------------------------------------------------------
 
 
+@app.get("/favicon.ico", include_in_schema=False)
+async def favicon_no_content() -> Response:
+    """Avoid sending the browser's implicit favicon request into the SPA
+    fallback.  This build has no canonical ICO asset, so an honest 204 is
+    preferable to a fabricated icon or the previous local-dev 500."""
+    return Response(status_code=204, headers={"Cache-Control": "public, max-age=86400"})
+
+
 
 @app.get("/")
 async def spa_root():
@@ -13288,11 +13410,11 @@ try:
 
     _a11oy_source_observation = {
         "repository": "szl-holdings/a11oy",
-        "commit": "adac37574f88a30ff099f3ec7f548685d4166e6f",
+        "commit": "2ca22d0b337805a2d4e7e65af3f6738c401431a4",
         "path": "",
         "relation": "declared-source-with-hf-overlay",
         "state": "VERIFIED_REFERENCE",
-        "evidence_url": "https://github.com/szl-holdings/a11oy/commit/adac37574f88a30ff099f3ec7f548685d4166e6f",
+        "evidence_url": "https://github.com/szl-holdings/a11oy/commit/2ca22d0b337805a2d4e7e65af3f6738c401431a4",
     }
     _szl_source_result = _szl_source_attestation.register(
         app,

szl3d_holographic.py

@@ -38,6 +38,7 @@ from urllib.request import Request, urlopen
 
 # Surface slots (id, human title) — the frontier tier + the 9 estate surfaces.
 SURFACES: List[Dict[str, str]] = [
+    {"id": "integritycontrol", "cat": "governance", "title": "Integrity Control Plane", "owner": "Wave15"},
     {"id": "atlas", "cat": "map", "flag": True, "title": "Atlas", "owner": "Wave27"},
     {"id": "frontier", "cat": "map", "title": "Frontier", "owner": "Dev0"},
     {"id": "neuromorphic", "cat": "more", "title": "Neuromorphic", "owner": "Dev0"},

szl_be_hardening.py

@@ -276,6 +276,11 @@ class DurableKhipu:
         self._lock = threading.RLock()
         self.backend = "memory"
         self._mem: List[Dict[str, Any]] = []
+        # SQLite connections are deliberately short-lived. A process-global
+        # connection kept the database file locked on Windows and made clean
+        # restart/deployment tests fail at directory teardown. Each operation
+        # opens a transaction-scoped connection instead; the on-disk chain is the
+        # state, not a connection object.
         self._db: Optional[sqlite3.Connection] = None
         self._json_path: Optional[str] = None
 
@@ -287,14 +292,13 @@ class DurableKhipu:
 
         try:
             os.makedirs(os.path.dirname(self._path), exist_ok=True)
-            self._db = sqlite3.connect(self._path, check_same_thread=False)
-            self._db.execute(
-                "CREATE TABLE IF NOT EXISTS khipu ("
-                "seq INTEGER PRIMARY KEY, action TEXT NOT NULL, "
-                "payload TEXT NOT NULL, prev TEXT NOT NULL, "
-                "digest TEXT NOT NULL, ts REAL NOT NULL)"
-            )
-            self._db.commit()
+            with sqlite3.connect(self._path, timeout=30.0) as db:
+                db.execute(
+                    "CREATE TABLE IF NOT EXISTS khipu ("
+                    "seq INTEGER PRIMARY KEY, action TEXT NOT NULL, "
+                    "payload TEXT NOT NULL, prev TEXT NOT NULL, "
+                    "digest TEXT NOT NULL, ts REAL NOT NULL)"
+                )
             self.backend = "sqlite"
         except Exception:  # disk unwritable -> JSON file fallback
             try:
@@ -313,21 +317,24 @@ class DurableKhipu:
         return hashlib.sha3_256(raw).hexdigest()
 
     def _all(self) -> List[Dict[str, Any]]:
-        if self.backend == "sqlite" and self._db is not None:
-            cur = self._db.execute(
-                "SELECT seq, action, payload, prev, digest, ts FROM khipu ORDER BY seq"
-            )
+        if self.backend == "sqlite":
+            with sqlite3.connect(self._path, timeout=30.0) as db:
+                rows = db.execute(
+                    "SELECT seq, action, payload, prev, digest, ts "
+                    "FROM khipu ORDER BY seq"
+                ).fetchall()
             return [
                 {"seq": r[0], "action": r[1], "payload": json.loads(r[2]),
                  "prev": r[3], "digest": r[4], "ts": r[5]}
-                for r in cur.fetchall()
+                for r in rows
             ]
         return list(self._mem)
 
     def count(self) -> int:
         with self._lock:
-            if self.backend == "sqlite" and self._db is not None:
-                return int(self._db.execute("SELECT COUNT(*) FROM khipu").fetchone()[0])
+            if self.backend == "sqlite":
+                with sqlite3.connect(self._path, timeout=30.0) as db:
+                    return int(db.execute("SELECT COUNT(*) FROM khipu").fetchone()[0])
             return len(self._mem)
 
     def head(self) -> str:
@@ -338,22 +345,36 @@ class DurableKhipu:
     def emit(self, action: str, payload: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         payload = payload or {}
         with self._lock:
-            rows = self._all()
-            prev = rows[-1]["digest"] if rows else _GENESIS
-            seq = len(rows)
-            body = {"organ": self.organ, "ns": self.ns, "seq": seq,
-                    "action": action, "payload": payload, "prev": prev}
-            digest = self._digest(body)
-            ts = time.time()
-            rec = dict(body, digest=digest, ts=ts)
-            if self.backend == "sqlite" and self._db is not None:
-                self._db.execute(
-                    "INSERT INTO khipu(seq, action, payload, prev, digest, ts) "
-                    "VALUES (?,?,?,?,?,?)",
-                    (seq, action, json.dumps(payload, sort_keys=True), prev, digest, ts),
-                )
-                self._db.commit()
+            if self.backend == "sqlite":
+                # BEGIN IMMEDIATE serializes concurrent writers, including two
+                # independently-opened stores after a rolling process restart.
+                with sqlite3.connect(self._path, timeout=30.0) as db:
+                    db.execute("BEGIN IMMEDIATE")
+                    last = db.execute(
+                        "SELECT seq, digest FROM khipu ORDER BY seq DESC LIMIT 1"
+                    ).fetchone()
+                    seq = int(last[0]) + 1 if last else 0
+                    prev = str(last[1]) if last else _GENESIS
+                    body = {"organ": self.organ, "ns": self.ns, "seq": seq,
+                            "action": action, "payload": payload, "prev": prev}
+                    digest = self._digest(body)
+                    ts = time.time()
+                    rec = dict(body, digest=digest, ts=ts)
+                    db.execute(
+                        "INSERT INTO khipu(seq, action, payload, prev, digest, ts) "
+                        "VALUES (?,?,?,?,?,?)",
+                        (seq, action, json.dumps(payload, sort_keys=True), prev, digest, ts),
+                    )
+                return rec
             else:
+                rows = self._all()
+                prev = rows[-1]["digest"] if rows else _GENESIS
+                seq = len(rows)
+                body = {"organ": self.organ, "ns": self.ns, "seq": seq,
+                        "action": action, "payload": payload, "prev": prev}
+                digest = self._digest(body)
+                ts = time.time()
+                rec = dict(body, digest=digest, ts=ts)
                 self._mem.append(rec)
                 if self.backend == "json" and self._json_path:
                     with open(self._json_path, "w") as fh:
@@ -609,6 +630,7 @@ def harden(app: Any, organ: str, ns: Optional[str] = None,
     # Gradio whose combined schema generation can raise; in that case we fall
     # back to FastAPI's get_openapi over THIS app's own APIRoutes (still a real,
     # auto-generated spec — never a hand-written stub).
+    @app.get("/openapi.json", include_in_schema=False)
     @app.get(f"/api/{organ}/openapi.json", include_in_schema=False)
     async def _organ_openapi():
         try:
@@ -642,7 +664,8 @@ def harden(app: Any, organ: str, ns: Optional[str] = None,
                     status_code=500,
                 )
 
-    report["registered"].append(f"openapi:/api/{organ}/openapi.json")
+    report["registered"].append(
+        f"openapi:/api/{organ}/openapi.json+alias:/openapi.json")
 
     # ---- 9: honest footer -------------------------------------------------
     @app.get("/honest", tags=["doctrine"])

szl_claim_rupture_gate.py

@@ -0,0 +1,476 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""SZL Claim Rupture Gate -- fail-closed claim-integrity assessment.
+
+This module is deliberately smaller than a fact-checker.  It does not browse, retrieve,
+infer truth, resolve contradictions, or calculate semantic uncertainty.  It accepts
+explicit claim atoms, evidence/provenance references, accountable consequence owners,
+and *externally supplied* factuality/uncertainty signals.  It then applies a transparent,
+deterministic rubric that decides whether a claim may be carried forward for human review.
+
+The contract is honest by construction:
+
+* raw prose atomization is STRUCTURAL-SPLIT-ONLY and must be human reviewed;
+* a claimed evidence label is never upgraded;
+* missing provenance, ownership, malformed signals, or contradictions fail closed;
+* VERIFIED requires traceable verification for every evidence reference plus an external,
+  traceable VERIFIED factuality signal;
+* every result is PROPOSAL_ONLY with zero effectors;
+* receipts are unsigned SHA-256 content digests, not signatures or truth certificates.
+
+This adds no theorem and changes no locked formula.  It is pure Python stdlib and performs
+no I/O, persistence, networking, authentication, signing, or mutation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any, Iterable, Mapping, Sequence
+
+
+VERIFIED = "VERIFIED"
+SUPPORTED = "SUPPORTED"
+UNCERTAIN = "UNCERTAIN"
+REFUTED = "REFUTED"
+UNKNOWN = "UNKNOWN"
+CLAIM_STATES = (VERIFIED, SUPPORTED, UNCERTAIN, REFUTED, UNKNOWN)
+
+PROPOSAL_ONLY = "PROPOSAL_ONLY"
+NO_EFFECTORS = 0
+SEMANTIC_UNCERTAINTY_ABSTAIN_THRESHOLD = 0.66
+MODULE_ID = "szl-claim-rupture-gate"
+CONTRACT_VERSION = "1.0.0"
+
+_SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
+_SPLIT_RE = re.compile(r"(?:\r?\n)+|(?<=[.!?;])\s+")
+
+
+# Open, inspectable error/abstention rubric.  Codes are stable API data, not prose-only
+# documentation.  Integrators may display them verbatim and tests pin their semantics.
+ERROR_RUBRIC: dict[str, dict[str, Any]] = {
+    "RG-001": {
+        "condition": "missing or empty claim statement",
+        "default_state": UNKNOWN,
+        "abstain": True,
+    },
+    "RG-002": {
+        "condition": "claim atom has not been explicitly reviewed as atomic",
+        "default_state": UNKNOWN,
+        "abstain": True,
+    },
+    "RG-003": {
+        "condition": "no evidence reference supplied",
+        "default_state": UNKNOWN,
+        "abstain": True,
+    },
+    "RG-004": {
+        "condition": "evidence reference lacks traceable provenance",
+        "default_state": UNKNOWN,
+        "abstain": True,
+    },
+    "RG-005": {
+        "condition": "claim lacks an accountable consequence owner and scope",
+        "default_state": UNKNOWN,
+        "abstain": True,
+    },
+    "RG-006": {
+        "condition": "unresolved or confirmed contradiction affects the claim",
+        "default_state": UNCERTAIN,
+        "abstain": True,
+    },
+    "RG-007": {
+        "condition": "traceable evidence or factuality signal explicitly refutes claim",
+        "default_state": REFUTED,
+        "abstain": True,
+    },
+    "RG-008": {
+        "condition": "external semantic-uncertainty or factuality signal is malformed or untraceable",
+        "default_state": UNKNOWN,
+        "abstain": True,
+    },
+    "RG-009": {
+        "condition": "externally supplied semantic uncertainty meets abstention threshold",
+        "default_state": UNCERTAIN,
+        "abstain": True,
+    },
+    "RG-010": {
+        "condition": "evidence is inconclusive or explicitly uncertain",
+        "default_state": UNCERTAIN,
+        "abstain": True,
+    },
+}
+
+
+def _canonical_json(value: Any) -> str:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+
+
+def _digest(value: Any) -> str:
+    return hashlib.sha256(_canonical_json(value).encode("utf-8")).hexdigest()
+
+
+def _nonempty(value: Any) -> bool:
+    return isinstance(value, str) and bool(value.strip())
+
+
+def _stable_claim_id(statement: str, index: int) -> str:
+    # Missing caller IDs are not silently accepted.  This identifier merely lets the
+    # rejection be addressed deterministically in the response.
+    material = {"index": index, "statement": statement}
+    return f"unidentified-{_digest(material)[:16]}"
+
+
+def _provenance_complete(provenance: Any) -> bool:
+    """Traceability minimum: source identity plus digest or immutable receipt reference.
+
+    This validates shape only.  It does *not* dereference, replay, or cryptographically
+    verify the asserted provenance.
+    """
+    if not isinstance(provenance, Mapping):
+        return False
+    if not _nonempty(provenance.get("source_id")):
+        return False
+    digest = provenance.get("content_sha256")
+    receipt = provenance.get("receipt_ref")
+    return bool((_nonempty(digest) and _SHA256_RE.fullmatch(digest.strip()))
+                or _nonempty(receipt))
+
+
+def _owner_complete(owner: Any) -> bool:
+    return (isinstance(owner, Mapping)
+            and _nonempty(owner.get("owner_id"))
+            and _nonempty(owner.get("accountability_scope")))
+
+
+def atomize_text(text: str) -> dict[str, Any]:
+    """Produce deterministic *candidate* atoms from visible punctuation/newlines only.
+
+    This is not semantic atomization.  Each candidate is ``atomic=False`` and therefore
+    fails closed until a human explicitly reviews it and supplies evidence/ownership.
+    """
+    source = text if isinstance(text, str) else ""
+    pieces = [p.strip(" \t-*\u2022") for p in _SPLIT_RE.split(source) if p.strip(" \t-*\u2022")]
+    atoms = []
+    for index, statement in enumerate(pieces):
+        atoms.append({
+            "claim_id": f"candidate-{index + 1:04d}-{_digest(statement)[:12]}",
+            "statement": statement,
+            "atomic": False,
+            "atomization_state": "STRUCTURAL-SPLIT-ONLY",
+            "human_review_required": True,
+            "evidence_refs": [],
+            "consequence_owner": None,
+        })
+    return {
+        "module": MODULE_ID,
+        "contract_version": CONTRACT_VERSION,
+        "method": "VISIBLE-PUNCTUATION-AND-NEWLINE-SPLIT",
+        "semantic_atomization_computed": False,
+        "decision_state": PROPOSAL_ONLY,
+        "effectors_enabled": NO_EFFECTORS,
+        "candidate_count": len(atoms),
+        "atoms": atoms,
+    }
+
+
+def _validate_semantic_signal(signal: Any) -> tuple[dict[str, Any] | None, str | None]:
+    if signal is None:
+        return None, None
+    if not isinstance(signal, Mapping):
+        return None, "RG-008"
+    value = signal.get("value")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None, "RG-008"
+    if not 0.0 <= float(value) <= 1.0:
+        return None, "RG-008"
+    if not _nonempty(signal.get("source_ref")) or not _nonempty(signal.get("method")):
+        return None, "RG-008"
+    return {
+        "value": float(value),
+        "source_ref": signal["source_ref"].strip(),
+        "method": signal["method"].strip(),
+        "computed_by_gate": False,
+    }, None
+
+
+def _validate_factuality_signal(signal: Any) -> tuple[dict[str, Any] | None, str | None]:
+    if signal is None:
+        return None, None
+    if not isinstance(signal, Mapping):
+        return None, "RG-008"
+    state = str(signal.get("state", "")).strip().upper()
+    if state not in CLAIM_STATES:
+        return None, "RG-008"
+    if not _nonempty(signal.get("source_ref")) or not _nonempty(signal.get("method")):
+        return None, "RG-008"
+    return {
+        "state": state,
+        "source_ref": signal["source_ref"].strip(),
+        "method": signal["method"].strip(),
+        "computed_by_gate": False,
+    }, None
+
+
+def _contradiction_effects(claim_ids: set[str], contradictions: Any) -> dict[str, list[dict[str, Any]]]:
+    effects: dict[str, list[dict[str, Any]]] = {cid: [] for cid in claim_ids}
+    if contradictions is None:
+        return effects
+    if not isinstance(contradictions, Sequence) or isinstance(contradictions, (str, bytes)):
+        for cid in effects:
+            effects[cid].append({"status": "MALFORMED", "rubric_code": "RG-008"})
+        return effects
+    for raw in contradictions:
+        if not isinstance(raw, Mapping):
+            for cid in effects:
+                effects[cid].append({"status": "MALFORMED", "rubric_code": "RG-008"})
+            continue
+        ids = raw.get("claim_ids")
+        ids = [str(x) for x in ids] if isinstance(ids, Sequence) and not isinstance(ids, (str, bytes)) else []
+        status = str(raw.get("status", "UNRESOLVED")).strip().upper()
+        traceable = _provenance_complete(raw.get("provenance"))
+        refutes = raw.get("refutes_claim_ids")
+        refutes = {str(x) for x in refutes} if isinstance(refutes, Sequence) and not isinstance(refutes, (str, bytes)) else set()
+        for cid in set(ids) & claim_ids:
+            if not traceable:
+                effects[cid].append({"status": status, "rubric_code": "RG-004"})
+            elif status in {"UNRESOLVED", "CONFIRMED"}:
+                effects[cid].append({
+                    "status": status,
+                    "rubric_code": "RG-007" if cid in refutes else "RG-006",
+                    "provenance_traceable": True,
+                })
+            elif status == "RESOLVED" and not _nonempty(raw.get("resolution_ref")):
+                effects[cid].append({"status": status, "rubric_code": "RG-008"})
+    return effects
+
+
+def _base_evidence_state(evidence_refs: Any) -> tuple[str, list[str], list[dict[str, Any]]]:
+    errors: list[str] = []
+    normalized: list[dict[str, Any]] = []
+    if not isinstance(evidence_refs, Sequence) or isinstance(evidence_refs, (str, bytes)) or not evidence_refs:
+        return UNKNOWN, ["RG-003"], normalized
+
+    states: list[str] = []
+    for raw in evidence_refs:
+        if not isinstance(raw, Mapping) or not _nonempty(raw.get("reference_id")):
+            errors.append("RG-004")
+            continue
+        state = str(raw.get("evidence_state", UNKNOWN)).strip().upper()
+        if state not in CLAIM_STATES:
+            errors.append("RG-008")
+            state = UNKNOWN
+        provenance_ok = _provenance_complete(raw.get("provenance"))
+        if not provenance_ok:
+            errors.append("RG-004")
+        verification_ref = raw.get("verification_ref")
+        if state == VERIFIED and not _nonempty(verification_ref):
+            # A bare VERIFIED string is not traceable verification.
+            errors.append("RG-004")
+        states.append(state)
+        normalized.append({
+            "reference_id": raw.get("reference_id"),
+            "evidence_state": state,
+            "provenance_traceable": provenance_ok,
+            "verification_ref": verification_ref if _nonempty(verification_ref) else None,
+        })
+
+    if "RG-004" in errors or "RG-008" in errors or not normalized:
+        return UNKNOWN, sorted(set(errors or ["RG-004"])), normalized
+    if REFUTED in states:
+        errors.append("RG-007")
+        return REFUTED, sorted(set(errors)), normalized
+    if UNKNOWN in states:
+        return UNKNOWN, sorted(set(errors)), normalized
+    if UNCERTAIN in states:
+        errors.append("RG-010")
+        return UNCERTAIN, sorted(set(errors)), normalized
+    if all(s == VERIFIED for s in states):
+        return VERIFIED, sorted(set(errors)), normalized
+    return SUPPORTED, sorted(set(errors)), normalized
+
+
+def _state_min(a: str, b: str) -> str:
+    # Conservative partial order.  Explicit refutation dominates, then missing evidence,
+    # then uncertainty; SUPPORTED and VERIFIED are successively stronger.
+    rank = {REFUTED: 0, UNKNOWN: 1, UNCERTAIN: 2, SUPPORTED: 3, VERIFIED: 4}
+    return a if rank[a] <= rank[b] else b
+
+
+def _assess_atom(atom: Any, index: int, external: Any, contradictions: list[dict[str, Any]]) -> dict[str, Any]:
+    raw = atom if isinstance(atom, Mapping) else {}
+    statement = str(raw.get("statement", "")).strip()
+    claim_id = str(raw.get("claim_id", "")).strip() or _stable_claim_id(statement, index)
+    errors: list[str] = []
+
+    if not statement:
+        errors.append("RG-001")
+    if raw.get("atomic") is not True:
+        errors.append("RG-002")
+    if not _owner_complete(raw.get("consequence_owner")):
+        errors.append("RG-005")
+
+    state, evidence_errors, evidence = _base_evidence_state(raw.get("evidence_refs"))
+    errors.extend(evidence_errors)
+
+    ext = external if isinstance(external, Mapping) else {}
+    semantic, semantic_error = _validate_semantic_signal(ext.get("semantic_uncertainty"))
+    factuality, factuality_error = _validate_factuality_signal(ext.get("factuality"))
+    if semantic_error:
+        errors.append(semantic_error)
+        state = UNKNOWN
+    if factuality_error:
+        errors.append(factuality_error)
+        state = UNKNOWN
+
+    # Missing factuality never upgrades evidence.  Even completely VERIFIED evidence is
+    # only SUPPORTED at the claim level without a traceable external factuality verdict.
+    if factuality is None and state == VERIFIED:
+        state = SUPPORTED
+    elif factuality is not None:
+        state = _state_min(state, factuality["state"])
+        if factuality["state"] == REFUTED:
+            errors.append("RG-007")
+        elif factuality["state"] == UNCERTAIN:
+            errors.append("RG-010")
+
+    if semantic is not None and semantic["value"] >= SEMANTIC_UNCERTAINTY_ABSTAIN_THRESHOLD:
+        if state not in {REFUTED, UNKNOWN}:
+            state = UNCERTAIN
+        errors.append("RG-009")
+
+    for effect in contradictions:
+        errors.append(effect["rubric_code"])
+        if effect["rubric_code"] == "RG-007":
+            state = REFUTED
+        elif effect["rubric_code"] in {"RG-004", "RG-008"}:
+            state = UNKNOWN
+        elif state not in {REFUTED, UNKNOWN}:
+            state = UNCERTAIN
+
+    # Structural/ownership/provenance failures always fail closed to UNKNOWN, except an
+    # explicit refutation which remains visible as the stronger negative verdict.
+    if any(code in errors for code in {"RG-001", "RG-002", "RG-003", "RG-004", "RG-005", "RG-008"}):
+        if state != REFUTED:
+            state = UNKNOWN
+
+    errors = sorted(set(errors))
+    abstain = state in {UNCERTAIN, REFUTED, UNKNOWN} or any(ERROR_RUBRIC[c]["abstain"] for c in errors)
+    return {
+        "claim_id": claim_id,
+        "statement": statement,
+        "state": state,
+        "abstain_required": abstain,
+        "rubric_codes": errors,
+        "evidence_refs": evidence,
+        "consequence_owner": dict(raw.get("consequence_owner")) if _owner_complete(raw.get("consequence_owner")) else None,
+        "external_signals": {
+            "semantic_uncertainty": semantic,
+            "factuality": factuality,
+            "computed_by_gate": [],
+        },
+        "contradictions": contradictions,
+        "decision_state": PROPOSAL_ONLY,
+        "effectors_enabled": NO_EFFECTORS,
+    }
+
+
+def evaluate_claims(
+    claims: Iterable[Mapping[str, Any]],
+    *,
+    external_signals: Mapping[str, Mapping[str, Any]] | None = None,
+    contradictions: Sequence[Mapping[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Assess explicit claim atoms and return an unsigned, deterministic receipt.
+
+    ``external_signals`` is keyed by claim_id.  Values are retained as externally supplied
+    facts about the signal source; this gate never produces semantic/factuality scores.
+    """
+    materialized = list(claims) if not isinstance(claims, (str, bytes, Mapping)) else []
+    ids = set()
+    for index, raw in enumerate(materialized):
+        if isinstance(raw, Mapping):
+            statement = str(raw.get("statement", "")).strip()
+            ids.add(str(raw.get("claim_id", "")).strip() or _stable_claim_id(statement, index))
+    contradiction_map = _contradiction_effects(ids, contradictions)
+    external_signals = external_signals if isinstance(external_signals, Mapping) else {}
+
+    assessments = []
+    for index, atom in enumerate(materialized):
+        raw = atom if isinstance(atom, Mapping) else {}
+        statement = str(raw.get("statement", "")).strip()
+        claim_id = str(raw.get("claim_id", "")).strip() or _stable_claim_id(statement, index)
+        assessments.append(_assess_atom(
+            atom,
+            index,
+            external_signals.get(claim_id),
+            contradiction_map.get(claim_id, []),
+        ))
+
+    counts = {state: sum(1 for row in assessments if row["state"] == state) for state in CLAIM_STATES}
+    if not assessments:
+        overall = UNKNOWN
+        abstain = True
+    else:
+        overall = assessments[0]["state"]
+        for row in assessments[1:]:
+            overall = _state_min(overall, row["state"])
+        abstain = any(row["abstain_required"] for row in assessments)
+
+    core = {
+        "module": MODULE_ID,
+        "contract_version": CONTRACT_VERSION,
+        "decision_state": PROPOSAL_ONLY,
+        "effectors_enabled": NO_EFFECTORS,
+        "overall_state": overall,
+        "abstain_required": abstain,
+        "gate_outcome": "ABSTAIN" if abstain else "EVIDENCE-COMPLETE-FOR-HUMAN-REVIEW",
+        "claim_count": len(assessments),
+        "state_counts": counts,
+        "claims": assessments,
+        "signal_contract": {
+            "semantic_uncertainty": "EXTERNALLY-SUPPLIED-ONLY",
+            "factuality": "EXTERNALLY-SUPPLIED-ONLY",
+            "semantic_threshold": SEMANTIC_UNCERTAINTY_ABSTAIN_THRESHOLD,
+            "computed_by_gate": [],
+        },
+        "honesty_invariants": {
+            "no_truth_inference": True,
+            "no_contradiction_resolution": True,
+            "missing_provenance_fails_closed": True,
+            "all_outputs_proposal_only": True,
+            "effectors_are_zero": True,
+        },
+    }
+    return {
+        **core,
+        "receipt": {
+            "mode": "UNSIGNED-CONTENT-DIGEST",
+            "algorithm": "sha256",
+            "signed": False,
+            "content_sha256": _digest(core),
+            "attests_truth": False,
+        },
+    }
+
+
+def info() -> dict[str, Any]:
+    """Static contract description for a future additive API registration."""
+    return {
+        "module": MODULE_ID,
+        "contract_version": CONTRACT_VERSION,
+        "states": list(CLAIM_STATES),
+        "decision_state": PROPOSAL_ONLY,
+        "effectors_enabled": NO_EFFECTORS,
+        "rubric": ERROR_RUBRIC,
+        "intended_read_only_api": [
+            {"method": "GET", "path": "/api/a11oy/v1/claim-integrity/info", "mutates": False},
+            {"method": "POST", "path": "/api/a11oy/v1/claim-integrity/atomize", "mutates": False,
+             "note": "computational read; emits candidates only"},
+            {"method": "POST", "path": "/api/a11oy/v1/claim-integrity/evaluate", "mutates": False,
+             "note": "computational read; unsigned digest only"},
+        ],
+        "not_implemented_here": ["HTTP registration", "persistence", "signing", "effectors"],
+    }
+

szl_hub.py

@@ -217,22 +217,21 @@ def register(app: FastAPI) -> None:
     FastAPI's built-in Swagger UI also defaults to /docs and is registered first
     (at app construction), so it would otherwise shadow our tab. To keep BOTH and
     stay additive (zero regression), we relocate the OpenAPI/Swagger UI to /api/docs
-    and the raw schema to /api/openapi.json, then drop the original /docs + /redoc
-    + /openapi.json default routes. Nothing customer-facing or SPA-facing is lost;
-    the interactive API explorer simply moves under the /api/* namespace where it
-    belongs.
+    and keep /api/openapi.json as a legacy schema alias. The conventional
+    /openapi.json path is owned by backend hardening as an exact alias of the
+    curated /api/a11oy/openapi.json schema; this module must not delete it.
     """
     # --- relocate FastAPI's default docs so /docs is free for the branded tab ---
     try:
         from fastapi.openapi.docs import get_swagger_ui_html
 
-        _default_docs_paths = {"/docs", "/redoc", "/openapi.json"}
+        _default_docs_paths = {"/docs", "/redoc"}
         app.router.routes = [
             r for r in app.router.routes
             if getattr(r, "path", None) not in _default_docs_paths
         ]
         # Re-expose the schema + Swagger UI under /api/* (additive, not lost).
-        app.openapi_url = "/api/openapi.json"
+        app.openapi_url = "/api/a11oy/openapi.json"
 
         @app.get("/api/openapi.json", include_in_schema=False)
         async def _hub_openapi() -> JSONResponse:
@@ -279,7 +278,10 @@ def register(app: FastAPI) -> None:
 
         @app.get("/api/docs", include_in_schema=False)
         async def _hub_swagger():
-            return get_swagger_ui_html(openapi_url="/api/openapi.json", title="a11oy API — Swagger UI")
+            return get_swagger_ui_html(
+                openapi_url="/api/a11oy/openapi.json",
+                title="a11oy API — Swagger UI",
+            )
     except Exception:
         # If relocation fails for any reason, fall through: the branded /docs tab
         # still registers below; worst case Swagger keeps /docs. Never fatal.

szl_waqay_security_loop.py

@@ -0,0 +1,796 @@
+"""Waqay Security Loop: a pure, proposal-only remediation control model.
+
+This module is intentionally narrow.  It does not scan source code, patch a
+repository, publish an artifact, or operate a deployment.  It normalizes a
+small fleet catalog, derives evidence-bound findings from exact component
+matches, evaluates fail-closed admission gates, and emits replayable receipts
+for a bounded remediation proposal.
+
+Truth boundary
+--------------
+* Every transition is ``PROPOSAL_ONLY`` and declares ``effectors = 0``.
+* A content digest is tamper evidence, not a cryptographic signature.
+* DSSE signing is an optional caller-provided hook.  With no signer, the
+  envelope is explicitly ``UNSIGNED_NO_SIGNER_AVAILABLE``.
+* Gate success permits only the *next proposal state*.  It never authorizes an
+  external mutation.
+
+The implementation is standard-library only and performs no network, process,
+filesystem, registry, source-control, or deployment calls.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import re
+from dataclasses import asdict, dataclass, replace
+from enum import Enum
+from typing import Any, Callable, Iterable, Mapping, Sequence
+
+
+SCHEMA_VERSION = "szl.waqay.security-loop.v1"
+RECEIPT_PAYLOAD_TYPE = "application/vnd.szl.waqay-transition+json"
+MODE = "PROPOSAL_ONLY"
+EFFECTOR_COUNT = 0
+MAX_FINDINGS = 128
+MAX_AFFECTED_DEPLOYMENTS = 100
+MAX_PLAN_BATCHES = 10
+MAX_BATCH_SIZE = 25
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+
+
+class ContractError(ValueError):
+    """Raised when caller input violates the deterministic contract."""
+
+
+class TransitionDenied(ContractError):
+    """Raised when a state transition or gate is fail-closed."""
+
+
+class EvidenceState(str, Enum):
+    MEASURED = "MEASURED"
+    VERIFIED = "VERIFIED"
+    SUPPORTED = "SUPPORTED"
+    MODELED = "MODELED"
+    UNVERIFIED = "UNVERIFIED"
+    UNAVAILABLE = "UNAVAILABLE"
+    REFUTED = "REFUTED"
+
+
+class LoopState(str, Enum):
+    DETECTED = "DETECTED"
+    VALIDATED = "VALIDATED"
+    REMEDIATION_PROPOSED = "REMEDIATION_PROPOSED"
+    APPROVAL_REQUIRED = "APPROVAL_REQUIRED"
+    RECALL_PROPOSED = "RECALL_PROPOSED"
+    ROLLOFF_PROPOSED = "ROLLOFF_PROPOSED"
+
+
+class PlanKind(str, Enum):
+    RECALL = "RECALL"
+    ROLLOFF = "ROLLOFF"
+
+
+@dataclass(frozen=True)
+class Component:
+    name: str
+    version: str
+    purl: str
+
+
+@dataclass(frozen=True)
+class Artifact:
+    artifact_digest: str
+    sbom_digest: str
+    provenance_digest: str
+    signature_state: EvidenceState
+    components: tuple[Component, ...]
+
+
+@dataclass(frozen=True)
+class Deployment:
+    deployment_id: str
+    artifact_digest: str
+    environment: str
+    owner_identity: str
+    rollback_digest: str
+
+
+@dataclass(frozen=True)
+class FleetCatalog:
+    observed_at: str
+    artifacts: tuple[Artifact, ...]
+    deployments: tuple[Deployment, ...]
+    schema_version: str = SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class Advisory:
+    advisory_id: str
+    component_name: str
+    affected_versions: tuple[str, ...]
+    severity: str
+    evidence_digest: str
+    source_uri: str
+
+
+@dataclass(frozen=True)
+class Finding:
+    finding_id: str
+    advisory_id: str
+    component_name: str
+    component_version: str
+    artifact_digest: str
+    affected_deployments: tuple[str, ...]
+    advisory_evidence_digest: str
+    evidence_state: EvidenceState
+
+
+@dataclass(frozen=True)
+class GateInputs:
+    """Measured facts presented to the fail-closed proposal gate.
+
+    Booleans are deliberately explicit.  A missing or unknown fact must be
+    represented as ``False`` rather than inferred from another field.
+    """
+
+    sbom_verified: bool
+    vulnerability_validated: bool
+    provenance_verified: bool
+    artifact_signature_verified: bool
+    principal_verified: bool
+    human_approval_verified: bool
+    rollback_target_previously_admitted: bool
+    graph_trust: str
+    unresolved_contradiction: bool
+    principal_id: str
+    approval_id: str
+    validation_evidence_digest: str
+
+
+@dataclass(frozen=True)
+class GateResult:
+    gate_id: str
+    passed: bool
+    evidence_state: EvidenceState
+    detail: str
+
+
+@dataclass(frozen=True)
+class RemediationPlan:
+    plan_id: str
+    kind: PlanKind
+    finding_id: str
+    target_artifact_digest: str
+    rollback_digest: str
+    deployment_ids: tuple[str, ...]
+    batches: tuple[tuple[str, ...], ...]
+    max_parallel: int
+    stop_on_failed_health_gate: bool
+    effectors: int = EFFECTOR_COUNT
+    mode: str = MODE
+
+
+@dataclass(frozen=True)
+class LoopRecord:
+    finding: Finding
+    state: LoopState
+    sequence: int
+    last_receipt_digest: str | None = None
+    mode: str = MODE
+    effectors: int = EFFECTOR_COUNT
+
+
+DsseSigner = Callable[[Mapping[str, Any], str], Mapping[str, Any]]
+
+
+def canonical_json(value: Any) -> bytes:
+    """Return deterministic UTF-8 JSON bytes for hashing and replay."""
+
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def sha256_json(value: Any) -> str:
+    return hashlib.sha256(canonical_json(value)).hexdigest()
+
+
+def _require_text(value: str, name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ContractError(f"{name} must be a non-empty string")
+    return value.strip()
+
+
+def _require_sha256(value: str, name: str) -> str:
+    value = _require_text(value, name).lower()
+    if not _SHA256_RE.fullmatch(value):
+        raise ContractError(f"{name} must be a lowercase SHA-256 hex digest")
+    return value
+
+
+def _sorted_unique(values: Iterable[str], name: str) -> tuple[str, ...]:
+    cleaned = tuple(sorted({_require_text(v, name) for v in values}))
+    if not cleaned:
+        raise ContractError(f"{name} must contain at least one value")
+    return cleaned
+
+
+def normalize_catalog(catalog: FleetCatalog) -> FleetCatalog:
+    """Validate and canonically order a fleet catalog.
+
+    Duplicate artifact or deployment identifiers are rejected rather than
+    silently merged.  Every deployment must reference a catalog artifact, and
+    every rollback digest must also be present in the catalog.
+    """
+
+    if catalog.schema_version != SCHEMA_VERSION:
+        raise ContractError(f"unsupported schema_version: {catalog.schema_version}")
+    _require_text(catalog.observed_at, "observed_at")
+
+    artifact_ids: set[str] = set()
+    artifacts: list[Artifact] = []
+    for artifact in catalog.artifacts:
+        artifact_digest = _require_sha256(artifact.artifact_digest, "artifact_digest")
+        if artifact_digest in artifact_ids:
+            raise ContractError(f"duplicate artifact_digest: {artifact_digest}")
+        artifact_ids.add(artifact_digest)
+        sbom_digest = _require_sha256(artifact.sbom_digest, "sbom_digest")
+        provenance_digest = _require_sha256(artifact.provenance_digest, "provenance_digest")
+        if not isinstance(artifact.signature_state, EvidenceState):
+            raise ContractError("signature_state must be an EvidenceState")
+        seen_components: set[tuple[str, str, str]] = set()
+        components: list[Component] = []
+        for component in artifact.components:
+            key = (
+                _require_text(component.name, "component.name"),
+                _require_text(component.version, "component.version"),
+                _require_text(component.purl, "component.purl"),
+            )
+            if key in seen_components:
+                raise ContractError(f"duplicate component in artifact {artifact_digest}: {key}")
+            seen_components.add(key)
+            components.append(Component(*key))
+        if not components:
+            raise ContractError(f"artifact {artifact_digest} has no SBOM components")
+        artifacts.append(
+            replace(
+                artifact,
+                artifact_digest=artifact_digest,
+                sbom_digest=sbom_digest,
+                provenance_digest=provenance_digest,
+                components=tuple(sorted(components, key=lambda c: (c.purl, c.version, c.name))),
+            )
+        )
+
+    if not artifacts:
+        raise ContractError("catalog must contain at least one artifact")
+
+    deployment_ids: set[str] = set()
+    deployments: list[Deployment] = []
+    for deployment in catalog.deployments:
+        deployment_id = _require_text(deployment.deployment_id, "deployment_id")
+        if deployment_id in deployment_ids:
+            raise ContractError(f"duplicate deployment_id: {deployment_id}")
+        deployment_ids.add(deployment_id)
+        artifact_digest = _require_sha256(deployment.artifact_digest, "deployment.artifact_digest")
+        rollback_digest = _require_sha256(deployment.rollback_digest, "deployment.rollback_digest")
+        if artifact_digest not in artifact_ids:
+            raise ContractError(f"deployment {deployment_id} references unknown artifact")
+        if rollback_digest not in artifact_ids:
+            raise ContractError(f"deployment {deployment_id} rollback digest is not admitted")
+        deployments.append(
+            replace(
+                deployment,
+                deployment_id=deployment_id,
+                artifact_digest=artifact_digest,
+                rollback_digest=rollback_digest,
+                environment=_require_text(deployment.environment, "environment"),
+                owner_identity=_require_text(deployment.owner_identity, "owner_identity"),
+            )
+        )
+
+    return FleetCatalog(
+        observed_at=catalog.observed_at,
+        artifacts=tuple(sorted(artifacts, key=lambda a: a.artifact_digest)),
+        deployments=tuple(sorted(deployments, key=lambda d: d.deployment_id)),
+    )
+
+
+def catalog_payload(catalog: FleetCatalog) -> dict[str, Any]:
+    normalized = normalize_catalog(catalog)
+    return _jsonable(normalized)
+
+
+def catalog_digest(catalog: FleetCatalog) -> str:
+    return sha256_json(catalog_payload(catalog))
+
+
+def security_loop_manifest() -> dict[str, Any]:
+    """Return a deterministic public contract suitable for a read-only route."""
+
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "mode": MODE,
+        "effectors": EFFECTOR_COUNT,
+        "external_mutations": "DISABLED",
+        "state_machine": [state.value for state in LoopState],
+        "gate_ids": [result.gate_id for result in evaluate_gates(_manifest_gate_fixture())],
+        "bounds": {
+            "max_findings": MAX_FINDINGS,
+            "max_affected_deployments": MAX_AFFECTED_DEPLOYMENTS,
+            "max_plan_batches": MAX_PLAN_BATCHES,
+            "max_batch_size": MAX_BATCH_SIZE,
+        },
+        "receipt": {
+            "content_addressed": True,
+            "payload_type": RECEIPT_PAYLOAD_TYPE,
+            "signature_default": "UNSIGNED_NO_SIGNER_AVAILABLE",
+            "signature_verification": "EXTERNAL_VERIFIER_REQUIRED",
+        },
+        "truth_boundary": (
+            "Gate success permits only the next proposal state; this module has no external effectors."
+        ),
+    }
+
+
+def _manifest_gate_fixture() -> GateInputs:
+    """Internal false fixture used only to enumerate the stable gate contract."""
+
+    return GateInputs(
+        sbom_verified=False,
+        vulnerability_validated=False,
+        provenance_verified=False,
+        artifact_signature_verified=False,
+        principal_verified=False,
+        human_approval_verified=False,
+        rollback_target_previously_admitted=False,
+        graph_trust=EvidenceState.UNAVAILABLE.value,
+        unresolved_contradiction=True,
+        principal_id="unavailable",
+        approval_id="unavailable",
+        validation_evidence_digest="",
+    )
+
+
+def detect_findings(
+    catalog: FleetCatalog,
+    advisories: Sequence[Advisory],
+    *,
+    max_findings: int = MAX_FINDINGS,
+) -> tuple[Finding, ...]:
+    """Derive deterministic findings from exact name/version matches.
+
+    This is deliberately not a semantic version-range evaluator.  Advisory
+    adapters must normalize affected versions to explicit values first.
+    """
+
+    normalized = normalize_catalog(catalog)
+    if not 1 <= max_findings <= MAX_FINDINGS:
+        raise ContractError(f"max_findings must be between 1 and {MAX_FINDINGS}")
+
+    deployments_by_artifact: dict[str, tuple[str, ...]] = {}
+    for artifact in normalized.artifacts:
+        deployments_by_artifact[artifact.artifact_digest] = tuple(
+            d.deployment_id
+            for d in normalized.deployments
+            if d.artifact_digest == artifact.artifact_digest
+        )
+
+    normalized_advisories: list[Advisory] = []
+    advisory_ids: set[str] = set()
+    for advisory in advisories:
+        advisory_id = _require_text(advisory.advisory_id, "advisory_id")
+        if advisory_id in advisory_ids:
+            raise ContractError(f"duplicate advisory_id: {advisory_id}")
+        advisory_ids.add(advisory_id)
+        versions = _sorted_unique(advisory.affected_versions, "affected_versions")
+        normalized_advisories.append(
+            replace(
+                advisory,
+                advisory_id=advisory_id,
+                component_name=_require_text(advisory.component_name, "component_name"),
+                affected_versions=versions,
+                severity=_require_text(advisory.severity, "severity").upper(),
+                evidence_digest=_require_sha256(advisory.evidence_digest, "advisory.evidence_digest"),
+                source_uri=_require_text(advisory.source_uri, "source_uri"),
+            )
+        )
+
+    findings: list[Finding] = []
+    for advisory in sorted(normalized_advisories, key=lambda a: a.advisory_id):
+        versions = set(advisory.affected_versions)
+        for artifact in normalized.artifacts:
+            for component in artifact.components:
+                if component.name != advisory.component_name or component.version not in versions:
+                    continue
+                subject = {
+                    "advisory_id": advisory.advisory_id,
+                    "component_name": component.name,
+                    "component_version": component.version,
+                    "artifact_digest": artifact.artifact_digest,
+                    "advisory_evidence_digest": advisory.evidence_digest,
+                }
+                findings.append(
+                    Finding(
+                        finding_id="waqay:" + sha256_json(subject),
+                        advisory_id=advisory.advisory_id,
+                        component_name=component.name,
+                        component_version=component.version,
+                        artifact_digest=artifact.artifact_digest,
+                        affected_deployments=deployments_by_artifact[artifact.artifact_digest],
+                        advisory_evidence_digest=advisory.evidence_digest,
+                        evidence_state=EvidenceState.MEASURED,
+                    )
+                )
+                if len(findings) > max_findings:
+                    raise ContractError("finding bound exceeded; narrow the advisory or catalog scope")
+    return tuple(sorted(findings, key=lambda f: f.finding_id))
+
+
+def evaluate_gates(gates: GateInputs) -> tuple[GateResult, ...]:
+    """Evaluate independent, explicit proposal gates without aggregation loss."""
+
+    validation_digest_ok = bool(_SHA256_RE.fullmatch(gates.validation_evidence_digest.lower()))
+    principal_present = bool(gates.principal_id.strip())
+    approval_present = bool(gates.approval_id.strip())
+    trust_ok = gates.graph_trust in {EvidenceState.VERIFIED.value, EvidenceState.MEASURED.value}
+    checks = (
+        ("SBOM_VERIFIED", gates.sbom_verified, "SBOM digest independently verified"),
+        ("VULNERABILITY_VALIDATED", gates.vulnerability_validated and validation_digest_ok,
+         "technical witness has a valid content digest"),
+        ("PROVENANCE_VERIFIED", gates.provenance_verified, "build provenance verified"),
+        ("ARTIFACT_SIGNATURE_VERIFIED", gates.artifact_signature_verified, "artifact signature verified"),
+        ("PRINCIPAL_VERIFIED", gates.principal_verified and principal_present, "principal identity verified"),
+        ("HUMAN_APPROVAL_VERIFIED", gates.human_approval_verified and approval_present,
+         "human approval evidence verified"),
+        ("ROLLBACK_ADMITTED", gates.rollback_target_previously_admitted,
+         "rollback target was previously admitted"),
+        ("GRAPH_TRUST", trust_ok, "query-specific graph trust is measured or verified"),
+        ("NO_UNRESOLVED_CONTRADICTION", not gates.unresolved_contradiction,
+         "no unresolved contradiction affects the target"),
+    )
+    return tuple(
+        GateResult(
+            gate_id=gate_id,
+            passed=passed,
+            evidence_state=EvidenceState.VERIFIED if passed else EvidenceState.UNVERIFIED,
+            detail=detail if passed else f"BLOCKED: {detail}",
+        )
+        for gate_id, passed, detail in checks
+    )
+
+
+def _all_gates_pass(results: Sequence[GateResult]) -> bool:
+    return bool(results) and all(result.passed for result in results)
+
+
+def make_plan(
+    *,
+    kind: PlanKind,
+    finding: Finding,
+    target_artifact_digest: str,
+    rollback_digest: str,
+    deployment_ids: Sequence[str],
+    batch_size: int = 10,
+    max_parallel: int = 2,
+) -> RemediationPlan:
+    """Create a bounded plan description; never invoke an effector."""
+
+    target = _require_sha256(target_artifact_digest, "target_artifact_digest")
+    rollback = _require_sha256(rollback_digest, "rollback_digest")
+    deployments = _sorted_unique(deployment_ids, "deployment_ids")
+    if deployments != tuple(sorted(finding.affected_deployments)):
+        raise ContractError("plan deployment set must exactly match the finding blast radius")
+    if len(deployments) > MAX_AFFECTED_DEPLOYMENTS:
+        raise ContractError("affected deployment bound exceeded")
+    if not 1 <= batch_size <= MAX_BATCH_SIZE:
+        raise ContractError(f"batch_size must be between 1 and {MAX_BATCH_SIZE}")
+    if not 1 <= max_parallel <= batch_size:
+        raise ContractError("max_parallel must be between 1 and batch_size")
+    batches = tuple(
+        deployments[index:index + batch_size]
+        for index in range(0, len(deployments), batch_size)
+    )
+    if len(batches) > MAX_PLAN_BATCHES:
+        raise ContractError("plan batch bound exceeded")
+    plan_subject = {
+        "kind": kind.value,
+        "finding_id": finding.finding_id,
+        "target_artifact_digest": target,
+        "rollback_digest": rollback,
+        "deployment_ids": deployments,
+        "batches": batches,
+        "max_parallel": max_parallel,
+        "mode": MODE,
+        "effectors": EFFECTOR_COUNT,
+    }
+    return RemediationPlan(
+        plan_id="waqay-plan:" + sha256_json(plan_subject),
+        kind=kind,
+        finding_id=finding.finding_id,
+        target_artifact_digest=target,
+        rollback_digest=rollback,
+        deployment_ids=deployments,
+        batches=batches,
+        max_parallel=max_parallel,
+        stop_on_failed_health_gate=True,
+    )
+
+
+_ALLOWED_TRANSITIONS: dict[LoopState, frozenset[LoopState]] = {
+    LoopState.DETECTED: frozenset({LoopState.VALIDATED}),
+    LoopState.VALIDATED: frozenset({LoopState.REMEDIATION_PROPOSED}),
+    LoopState.REMEDIATION_PROPOSED: frozenset({LoopState.APPROVAL_REQUIRED}),
+    LoopState.APPROVAL_REQUIRED: frozenset({LoopState.RECALL_PROPOSED}),
+    LoopState.RECALL_PROPOSED: frozenset({LoopState.ROLLOFF_PROPOSED}),
+    LoopState.ROLLOFF_PROPOSED: frozenset(),
+}
+
+
+def start_record(finding: Finding) -> LoopRecord:
+    if not finding.finding_id.startswith("waqay:"):
+        raise ContractError("finding_id must be content-addressed by this contract")
+    return LoopRecord(finding=finding, state=LoopState.DETECTED, sequence=0)
+
+
+def transition(
+    record: LoopRecord,
+    next_state: LoopState,
+    *,
+    observed_at: str,
+    rationale: str,
+    gates: GateInputs | None = None,
+    plan: RemediationPlan | None = None,
+    signer: DsseSigner | None = None,
+) -> tuple[LoopRecord, dict[str, Any]]:
+    """Return a new immutable record and a replayable transition receipt.
+
+    Gate policy:
+    * ``VALIDATED`` requires reproducible vulnerability evidence.
+    * ``APPROVAL_REQUIRED`` records that approval is required, not granted.
+    * recall/rolloff proposals require every supply-chain, identity, graph, and
+      rollback gate, plus a matching bounded plan.
+    """
+
+    if next_state not in _ALLOWED_TRANSITIONS[record.state]:
+        raise TransitionDenied(f"transition {record.state.value} -> {next_state.value} is not allowed")
+    _require_text(observed_at, "observed_at")
+    rationale = _require_text(rationale, "rationale")
+    gate_results = evaluate_gates(gates) if gates is not None else tuple()
+
+    if next_state is LoopState.VALIDATED:
+        if gates is None:
+            raise TransitionDenied("VALIDATED requires gate evidence")
+        required = next(result for result in gate_results if result.gate_id == "VULNERABILITY_VALIDATED")
+        if not required.passed:
+            raise TransitionDenied("vulnerability validation evidence is missing or invalid")
+
+    if next_state in {LoopState.RECALL_PROPOSED, LoopState.ROLLOFF_PROPOSED}:
+        if gates is None or not _all_gates_pass(gate_results):
+            raise TransitionDenied("all safety, identity, provenance, and rollback gates must pass")
+        if plan is None:
+            raise TransitionDenied("recall/rolloff proposal requires a bounded plan")
+        expected_kind = PlanKind.RECALL if next_state is LoopState.RECALL_PROPOSED else PlanKind.ROLLOFF
+        if plan.kind is not expected_kind:
+            raise TransitionDenied(f"{next_state.value} requires a {expected_kind.value} plan")
+        if plan.finding_id != record.finding.finding_id:
+            raise TransitionDenied("plan finding does not match record finding")
+        if plan.mode != MODE or plan.effectors != EFFECTOR_COUNT:
+            raise TransitionDenied("plan must remain proposal-only with zero effectors")
+
+    payload: dict[str, Any] = {
+        "schema_version": SCHEMA_VERSION,
+        "mode": MODE,
+        "effectors": EFFECTOR_COUNT,
+        "sequence": record.sequence + 1,
+        "observed_at": observed_at,
+        "finding_id": record.finding.finding_id,
+        "from_state": record.state.value,
+        "to_state": next_state.value,
+        "rationale": rationale,
+        "previous_receipt_digest": record.last_receipt_digest,
+        "gate_results": [_jsonable(result) for result in gate_results],
+        "plan": _jsonable(plan) if plan is not None else None,
+        "truth_labels": {
+            "external_mutation": "NOT_PERFORMED",
+            "authorization_scope": "NEXT_PROPOSAL_STATE_ONLY",
+            "model_output": "NOT_USED_BY_CORE_STATE_MACHINE",
+            "signature_claim": "DETERMINED_BY_DSSE_ENVELOPE",
+        },
+    }
+    receipt_digest = sha256_json(payload)
+    envelope = _make_dsse_envelope(payload, signer)
+    receipt = {
+        "receipt_digest": receipt_digest,
+        "payload": payload,
+        "dsse_envelope": envelope,
+    }
+    updated = LoopRecord(
+        finding=record.finding,
+        state=next_state,
+        sequence=record.sequence + 1,
+        last_receipt_digest=receipt_digest,
+    )
+    return updated, receipt
+
+
+def _make_dsse_envelope(payload: Mapping[str, Any], signer: DsseSigner | None) -> dict[str, Any]:
+    body = canonical_json(payload)
+    encoded = base64.b64encode(body).decode("ascii")
+    if signer is None:
+        return {
+            "payloadType": RECEIPT_PAYLOAD_TYPE,
+            "payload": encoded,
+            "signatures": [],
+            "signed": False,
+            "verification_state": "UNSIGNED_NO_SIGNER_AVAILABLE",
+            "honesty": "No signer hook supplied; no signature fabricated.",
+        }
+    envelope = dict(signer(payload, RECEIPT_PAYLOAD_TYPE))
+    if envelope.get("payloadType") != RECEIPT_PAYLOAD_TYPE or envelope.get("payload") != encoded:
+        raise ContractError("DSSE signer returned an envelope for different payload bytes")
+    signatures = envelope.get("signatures")
+    envelope["signed"] = bool(signatures)
+    envelope["verification_state"] = (
+        "SIGNED_NOT_VERIFIED_BY_THIS_MODULE" if signatures else "UNSIGNED_SIGNER_RETURNED_NO_SIGNATURE"
+    )
+    return envelope
+
+
+def szl_dsse_signer_hook(payload: Mapping[str, Any], payload_type: str) -> Mapping[str, Any]:
+    """Optional adapter to the repository's existing DSSE implementation.
+
+    Import is delayed so the core control model remains standalone.  The
+    existing signer already returns an honest unsigned envelope when its
+    runtime secret is absent.
+    """
+
+    from szl_dsse import sign_payload  # type: ignore
+
+    return sign_payload(payload, payload_type)
+
+
+def verify_receipt(receipt: Mapping[str, Any]) -> dict[str, Any]:
+    """Verify content address and DSSE payload binding without trusting a key."""
+
+    try:
+        payload = receipt["payload"]
+        expected = sha256_json(payload)
+        digest_ok = receipt.get("receipt_digest") == expected
+        envelope = receipt["dsse_envelope"]
+        payload_bytes = base64.b64decode(envelope["payload"], validate=True)
+        envelope_payload_ok = payload_bytes == canonical_json(payload)
+        payload_type_ok = envelope.get("payloadType") == RECEIPT_PAYLOAD_TYPE
+        truth_ok = payload.get("mode") == MODE and payload.get("effectors") == EFFECTOR_COUNT
+        return {
+            "valid": digest_ok and envelope_payload_ok and payload_type_ok and truth_ok,
+            "digest_ok": digest_ok,
+            "envelope_payload_ok": envelope_payload_ok,
+            "payload_type_ok": payload_type_ok,
+            "proposal_only_ok": truth_ok,
+            "signature_verified": False,
+            "signature_note": "Signature verification requires an independent configured verifier.",
+        }
+    except (KeyError, TypeError, ValueError, json.JSONDecodeError) as exc:
+        return {"valid": False, "reason": f"malformed receipt: {type(exc).__name__}"}
+
+
+def replay_receipts(finding: Finding, receipts: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
+    """Replay an ordered receipt chain and reconstruct its final proposal state."""
+
+    state = LoopState.DETECTED
+    previous: str | None = None
+    expected_sequence = 1
+    for receipt in receipts:
+        verdict = verify_receipt(receipt)
+        if not verdict.get("valid"):
+            return {"valid": False, "sequence": expected_sequence, "reason": "receipt verification failed"}
+        payload = receipt["payload"]
+        try:
+            from_state = LoopState(payload["from_state"])
+            to_state = LoopState(payload["to_state"])
+        except (KeyError, ValueError):
+            return {"valid": False, "sequence": expected_sequence, "reason": "unknown transition state"}
+        if payload.get("sequence") != expected_sequence:
+            return {"valid": False, "sequence": expected_sequence, "reason": "sequence mismatch"}
+        if payload.get("finding_id") != finding.finding_id:
+            return {"valid": False, "sequence": expected_sequence, "reason": "finding mismatch"}
+        if payload.get("previous_receipt_digest") != previous:
+            return {"valid": False, "sequence": expected_sequence, "reason": "receipt chain mismatch"}
+        if from_state is not state or to_state not in _ALLOWED_TRANSITIONS[state]:
+            return {"valid": False, "sequence": expected_sequence, "reason": "state transition mismatch"}
+        gate_results = payload.get("gate_results")
+        if not isinstance(gate_results, list):
+            return {"valid": False, "sequence": expected_sequence, "reason": "gate results malformed"}
+        gate_map = {
+            item.get("gate_id"): item.get("passed")
+            for item in gate_results
+            if isinstance(item, Mapping)
+        }
+        if to_state is LoopState.VALIDATED and gate_map.get("VULNERABILITY_VALIDATED") is not True:
+            return {"valid": False, "sequence": expected_sequence, "reason": "validation gate not satisfied"}
+        if to_state in {LoopState.RECALL_PROPOSED, LoopState.ROLLOFF_PROPOSED}:
+            required_gate_ids = set(security_loop_manifest()["gate_ids"])
+            if set(gate_map) != required_gate_ids or not all(gate_map.values()):
+                return {"valid": False, "sequence": expected_sequence, "reason": "proposal gates not satisfied"}
+            plan = payload.get("plan")
+            expected_kind = "RECALL" if to_state is LoopState.RECALL_PROPOSED else "ROLLOFF"
+            if not isinstance(plan, Mapping) or plan.get("kind") != expected_kind:
+                return {"valid": False, "sequence": expected_sequence, "reason": "plan kind mismatch"}
+            if plan.get("finding_id") != finding.finding_id:
+                return {"valid": False, "sequence": expected_sequence, "reason": "plan finding mismatch"}
+            if plan.get("mode") != MODE or plan.get("effectors") != EFFECTOR_COUNT:
+                return {"valid": False, "sequence": expected_sequence, "reason": "plan truth boundary mismatch"}
+        state = to_state
+        previous = receipt["receipt_digest"]
+        expected_sequence += 1
+    return {
+        "valid": True,
+        "finding_id": finding.finding_id,
+        "final_state": state.value,
+        "receipt_count": len(receipts),
+        "last_receipt_digest": previous,
+        "mode": MODE,
+        "effectors": EFFECTOR_COUNT,
+        "verification_scope": "STRUCTURAL_CONTENT_AND_TRANSITION_ONLY",
+        "signature_verified": False,
+    }
+
+
+def _jsonable(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, Enum):
+        return value.value
+    if hasattr(value, "__dataclass_fields__"):
+        return _jsonable(asdict(value))
+    if isinstance(value, Mapping):
+        return {str(key): _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (tuple, list)):
+        return [_jsonable(item) for item in value]
+    return value
+
+
+__all__ = [
+    "Advisory",
+    "Artifact",
+    "Component",
+    "ContractError",
+    "Deployment",
+    "DsseSigner",
+    "EFFECTOR_COUNT",
+    "EvidenceState",
+    "FleetCatalog",
+    "Finding",
+    "GateInputs",
+    "GateResult",
+    "LoopRecord",
+    "LoopState",
+    "MAX_AFFECTED_DEPLOYMENTS",
+    "MODE",
+    "PlanKind",
+    "RemediationPlan",
+    "SCHEMA_VERSION",
+    "TransitionDenied",
+    "canonical_json",
+    "catalog_digest",
+    "catalog_payload",
+    "detect_findings",
+    "evaluate_gates",
+    "make_plan",
+    "normalize_catalog",
+    "replay_receipts",
+    "security_loop_manifest",
+    "sha256_json",
+    "start_record",
+    "szl_dsse_signer_hook",
+    "transition",
+    "verify_receipt",
+]