re-sweep wave2: ship 4 REAL 0-CDN operator surfaces — /sovereign-search (tantivy-wasm MIT), /consensus-clusters (ngraph.leiden MIT), /mission-ledger (research-arcade MIT), /budget-router (BudgetMem+MemSkill Apache, GraphPlanner MIT)

Dockerfile

@@ -392,6 +392,18 @@ COPY szl_abacus_verify.py ./szl_abacus_verify.py
 COPY szl_decision_uncertainty.py ./szl_decision_uncertainty.py
 COPY szl_gor_audit.py ./szl_gor_audit.py
 
+# ADDITIVE (RE-SWEEP WAVE 2, 2026-06, Yachay): four MORE operator surfaces from the
+# P0 re-sweep backlog, each adopting a PERMISSIVE pattern (MIT/Apache; NOTICE updated)
+# and evolving it into an a11oy-native mechanism. Stdlib-only (no torch/numpy/CDN);
+# graph tabs render with the already-vendored cytoscape. Per-file COPY (this Dockerfile
+# never uses `COPY . .`) -- without these the imports fail and /sovereign-search,
+# /consensus-clusters, /mission-ledger, /budget-router fall through to the SPA shell.
+# serve.py imports them try/except-guarded.
+COPY szl_sovereign_search.py ./szl_sovereign_search.py
+COPY szl_consensus_clusters.py ./szl_consensus_clusters.py
+COPY szl_mission_ledger.py ./szl_mission_ledger.py
+COPY szl_budget_router.py ./szl_budget_router.py
+
 CMD ["python", "serve.py"]
 
 

NOTICE

@@ -116,3 +116,56 @@ repositories, then evolve each into an original a11oy mechanism:
 
 Copyright (c) of each library belongs to its respective authors. Full license
 texts ship with each minified bundle's upstream distribution.
+
+================================================================================
+RE-SWEEP WAVE 2 PATTERN ADOPTION (fashion-thinking — permissive only, NOTICE
+attribution, EVOLVED into a11oy-native mechanisms; NO upstream source copied;
+stdlib-only clean-room re-implementations, 0 CDN; graph tabs use the already-
+vendored cytoscape)
+================================================================================
+Four additional additive operator surfaces adopt the PATTERN of the following
+founder-followed repositories, then evolve each into an original a11oy mechanism:
+
+  tantivy-wasm         — (c) phiresky                  — MIT License
+    https://github.com/phiresky/tantivy-wasm
+    Adopted: sovereign, in-deployment full-text search (no external search service,
+    no egress — the index lives with the data). Evolved -> Sovereign Corpus Search
+    (/sovereign-search): a dependency-free, stdlib-only Okapi BM25 engine indexing
+    the live governance corpus (model catalog, decision receipts, doctrine) so an
+    operator runs sub-second relevance search with ZERO backend service and ZERO CDN.
+    No Tantivy/Rust/WASM code; clean-room.
+
+  ngraph.leiden        — (c) Andrei Kashcha (anvaka)   — MIT License
+    https://github.com/anvaka/ngraph.leiden
+    Adopted: fast, deterministic community detection (Leiden/Louvain modularity).
+    Evolved -> Consensus Clusters (/consensus-clusters): a clean-room Louvain
+    modularity optimizer over a similarity graph of governed decision nodes (edges
+    weighted by shared sensitivity / mission tier / model family) that surfaces
+    consensus clusters and isolated outliers. No ngraph/JS source; rendered with the
+    already-vendored cytoscape (0 CDN).
+
+  research-arcade      — (c) ulab-uiuc                 — MIT License
+    https://github.com/ulab-uiuc/research-arcade
+    Adopted: heterogeneous graph interface unifying disparate structured sources with
+    typed nodes/edges. Evolved -> Mission Ledger (/mission-ledger): a live
+    heterogeneous knowledge graph over documents -> objectives -> decisions (decisions
+    drawn from the real Khipu chain) with typed edges (cites/supports/resulted_in) so
+    provenance from source material to governed action is explicit. No research-arcade
+    source, no SQL backend; rendered with the already-vendored cytoscape (0 CDN).
+
+  BudgetMem            — (c) ViktorAxelsen              — Apache-2.0  [ICML'26]
+    https://github.com/ViktorAxelsen/BudgetMem
+  MemSkill             — (c) ViktorAxelsen              — Apache-2.0
+    https://github.com/ViktorAxelsen/MemSkill
+  GraphPlanner         — (c) ulab-uiuc                  — MIT License  [ICLR'26]
+    https://github.com/ulab-uiuc/GraphPlanner
+    Adopted: BudgetMem module-level budget tiers (Low/Mid/High) + query-aware tier
+    router; MemSkill meta-memory ("learn WHAT to preserve"); GraphPlanner's
+    route-by-graph-signal idea. Evolved -> Budget-Tier Router + Decision Skeletons
+    (/budget-router): routes each governed decision by RISK (sensitivity x
+    reversibility) to the cheapest mission budget tier — Tactical (<=1s) / Operational
+    (<=10s) / Strategic (<=60s) — then to the smallest sufficient air-gap-safe model;
+    distils reusable "Decision Skeletons" as bounded meta-memory. Stdlib-only; no
+    BudgetMem/MemSkill/GraphPlanner source; clean-room.
+
+Copyright (c) of each library belongs to its respective authors.

serve.py

@@ -437,6 +437,31 @@ for _mined_mod in (
     except Exception as _mined_e:  # additive: never break the Space
         print(f"[a11oy] MINED-UPGRADE {_mined_mod} NOT registered: {_mined_e!r}; SPA + API unaffected", file=sys.stderr)
 
+# ---------------------------------------------------------------------------
+# ADDITIVE (RE-SWEEP WAVE 2, 2026-06, Yachay): four MORE self-contained,
+# dependency-free operator surfaces from the P0 re-sweep backlog. Same doctrine:
+# adopt a PERMISSIVE pattern (MIT/Apache), attribute in NOTICE, EVOLVE to an
+# a11oy-native mechanism. All stdlib-only (no torch/numpy/CDN); graph tabs render
+# with the ALREADY-VENDORED cytoscape (/vendor/*, 0 CDN). Registered BEFORE the SPA
+# catch-all; try/except-guarded so a missing dep can NEVER take the Space down.
+#   5) szl_sovereign_search    (tantivy-wasm MIT, phiresky)        -> /sovereign-search
+#   6) szl_consensus_clusters  (ngraph.leiden MIT, anvaka)          -> /consensus-clusters
+#   7) szl_mission_ledger      (research-arcade MIT, ulab-uiuc)     -> /mission-ledger
+#   8) szl_budget_router       (BudgetMem+MemSkill Apache; GraphPlanner MIT) -> /budget-router
+# ---------------------------------------------------------------------------
+for _resweep_mod in (
+    "szl_sovereign_search",
+    "szl_consensus_clusters",
+    "szl_mission_ledger",
+    "szl_budget_router",
+):
+    try:
+        _m = __import__(_resweep_mod)
+        _status = _m.register(app, ns="a11oy")
+        print(f"[a11oy] RESWEEP-W2 {_resweep_mod} registered: {_status}", file=sys.stderr)
+    except Exception as _rs_e:  # additive: never break the Space
+        print(f"[a11oy] RESWEEP-W2 {_resweep_mod} NOT registered: {_rs_e!r}; SPA + API unaffected", file=sys.stderr)
+
 
 # ---------------------------------------------------------------------------
 # Load gates manifest at startup

szl_budget_router.py

@@ -0,0 +1,349 @@
+# SPDX-License-Identifier: MIT
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+# Authored by A11oy Full-Stack Team. Co-Authored-By: Perplexity Computer Agent.
+#
+# THIRD-PARTY PATTERN ADOPTION (fashion-thinking, NOTICE attribution):
+#   BudgetMem — ViktorAxelsen/BudgetMem — Apache-2.0 —
+#   https://github.com/ViktorAxelsen/BudgetMem
+#   MemSkill — ViktorAxelsen/MemSkill — Apache-2.0 —
+#   https://github.com/ViktorAxelsen/MemSkill
+#   GraphPlanner — ulab-uiuc/GraphPlanner — MIT —
+#   https://github.com/ulab-uiuc/GraphPlanner
+#
+#   We adopt THREE patterns and EVOLVE them into one a11oy-native mechanism:
+#   • BudgetMem's module-level BUDGET TIERS (Low/Mid/High) + a lightweight query-aware
+#     budget-tier ROUTER. We map the tiers onto Warhacker MISSION CONSTRAINTS —
+#     Tactical (≤1s), Operational (≤10s), Strategic (≤1min) — so sovereign hardware is
+#     never choked by unnecessary chain-of-thought on a time-critical decision.
+#   • GraphPlanner's idea of routing by graph-derived signal: we route by DECISION RISK
+#     (sensitivity × time-budget × reversibility) rather than by learned RL value.
+#   • MemSkill's meta-memory ("learn WHAT to preserve"): we evolve it into "DECISION
+#     SKELETONS" — reusable, distilled patterns of how the substrate successfully
+#     navigated a class of governed trade-offs, kept across runs.
+#   Original, dependency-free implementation — no BudgetMem/MemSkill/GraphPlanner
+#   source, no torch/numpy. Reuses the live governance catalog from
+#   szl_governance_gateway when present. Λ = Conjecture 1. Doctrine v11 LOCKED 749/14/163.
+"""szl_budget_router — ADDITIVE cost-aware budget-tier router + Decision Skeletons.
+
+Endpoints (mounted before the SPA catch-all):
+  GET  /budget-router                              — operator tab (HTML, 0 CDN)
+  GET  /api/a11oy/v1/budget/tiers                   — the 3 mission budget tiers
+  POST /api/a11oy/v1/budget/route                   — route a decision by risk → tier → model
+  GET  /api/a11oy/v1/budget/skeletons               — learned Decision Skeletons (meta-memory)
+"""
+from __future__ import annotations
+
+import re
+import time
+from typing import Any
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+
+DOCTRINE = {"version": "v11", "counts": "749/14/163", "lambda": "Conjecture 1"}
+
+# --- Mission budget tiers (BudgetMem Low/Mid/High → Warhacker mission constraints) ---
+TIERS: list[dict[str, Any]] = [
+    {"tier": "TACTICAL", "budget": "LOW", "deadline_s": 1, "max_model_tier": "T1",
+     "cot": "none", "note": "time-critical: cheapest sufficient model, no chain-of-thought"},
+    {"tier": "OPERATIONAL", "budget": "MID", "deadline_s": 10, "max_model_tier": "T3",
+     "cot": "short", "note": "balanced: mid-tier reasoning with a short rationale"},
+    {"tier": "STRATEGIC", "budget": "HIGH", "deadline_s": 60, "max_model_tier": "T6",
+     "cot": "full", "note": "deliberate: high-tier model, full chain-of-thought permitted"},
+]
+_TIER_BY_NAME = {t["tier"]: t for t in TIERS}
+
+# Reversibility cues raise risk: an irreversible action deserves a bigger budget.
+_IRREVERSIBLE_RX = re.compile(
+    r"\b(launch|fire|strike|delete|destroy|deploy|commit|authoriz|release|publish|"
+    r"terminate|engage|weapon|kill)\b", re.I)
+_REVERSIBLE_RX = re.compile(r"\b(draft|preview|simulate|estimate|summari|triage|sort|list|query)\b", re.I)
+
+
+def _classify_sensitivity(text: str, declared: str | None) -> dict[str, Any]:
+    """Reuse the live governance classifier when present; else a safe fallback."""
+    try:
+        import szl_governance_gateway as _gg  # type: ignore
+        return _gg.classify(text, declared)
+    except Exception:
+        return {"class": (declared or "PUBLIC").upper(), "rank": 0, "signals": ["fallback"]}
+
+
+def _reversibility(text: str) -> tuple[float, str]:
+    if _IRREVERSIBLE_RX.search(text or ""):
+        return 1.0, "irreversible"
+    if _REVERSIBLE_RX.search(text or ""):
+        return 0.0, "reversible"
+    return 0.5, "uncertain"
+
+
+def assess_risk(query: str, *, declared: str | None = None,
+                deadline_s: float | None = None) -> dict[str, Any]:
+    """Decision risk = f(sensitivity, reversibility). Higher risk → higher tier.
+    A tighter deadline CAPS the tier (you cannot afford full CoT under 1s)."""
+    sens = _classify_sensitivity(query, declared)
+    sens_norm = sens["rank"] / 3.0  # 0..1 over PUBLIC..SECRET
+    rev_score, rev_label = _reversibility(query)
+    # Weighted risk: sensitivity dominates, reversibility modulates.
+    risk = round(0.65 * sens_norm + 0.35 * rev_score, 4)
+    if risk >= 0.6:
+        want = "STRATEGIC"
+    elif risk >= 0.3:
+        want = "OPERATIONAL"
+    else:
+        want = "TACTICAL"
+    # Deadline cap: if the operator imposes a tighter deadline, downshift the tier.
+    chosen = want
+    capped_by_deadline = False
+    if deadline_s is not None:
+        affordable = [t["tier"] for t in TIERS if t["deadline_s"] <= deadline_s]
+        order = ["TACTICAL", "OPERATIONAL", "STRATEGIC"]
+        if affordable:
+            best_affordable = max(affordable, key=lambda n: order.index(n))
+            if order.index(best_affordable) < order.index(want):
+                chosen = best_affordable
+                capped_by_deadline = True
+        else:
+            chosen = "TACTICAL"; capped_by_deadline = True
+    return {
+        "sensitivity": sens, "reversibility": {"score": rev_score, "label": rev_label},
+        "risk": risk, "risk_band": ("HIGH" if risk >= 0.6 else "MODERATE" if risk >= 0.3 else "LOW"),
+        "risk_implied_tier": want, "chosen_tier": chosen,
+        "capped_by_deadline": capped_by_deadline,
+    }
+
+
+def _pick_model(max_model_tier: str, sensitivity_rank: int) -> dict[str, Any] | None:
+    """Smallest sufficient model within the tier ceiling, respecting the air-gap floor."""
+    try:
+        import szl_governance_gateway as _gg  # type: ignore
+        cat = getattr(_gg, "CATALOG", [])
+        order = getattr(_gg, "_TIER_ORDER", {})
+        floor = getattr(_gg, "_AIRGAP_FLOOR", 2)
+    except Exception:
+        return None
+    ceil = order.get(max_model_tier, 9)
+    airgap_required = sensitivity_rank >= floor
+    elig = [m for m in cat
+            if order.get(m["tier"], 9) <= ceil
+            and (not airgap_required or m.get("zone") == "AIRGAP")]
+    if not elig:
+        return None
+    elig.sort(key=lambda m: (order.get(m["tier"], 9), -m.get("ctx", 0)))
+    return elig[0]
+
+
+def route(query: str, *, declared: str | None = None,
+          deadline_s: float | None = None) -> dict[str, Any]:
+    risk = assess_risk(query, declared=declared, deadline_s=deadline_s)
+    tier = _TIER_BY_NAME[risk["chosen_tier"]]
+    model = _pick_model(tier["max_model_tier"], risk["sensitivity"]["rank"])
+    decision = {
+        "query": query, "tier": tier, "risk": risk, "chosen_model": model,
+        "airgap_required": risk["sensitivity"]["rank"] >= 2,
+        "policy": "risk(sensitivity×reversibility) → mission tier (deadline-capped) → smallest sufficient air-gap-safe model",
+        "honest": None if model else "no model within tier ceiling + air-gap floor — raise the tier or add an AIRGAP model",
+    }
+    _learn_skeleton(decision)
+    return decision
+
+
+# ---------------------------------------------------------------------------
+# Decision Skeletons (MemSkill meta-memory, evolved). A skeleton is a DISTILLED,
+# reusable pattern for a class of decisions: (risk_band, tier, airgap) → how it was
+# handled, plus how many times that pattern recurred. We keep WHAT generalizes
+# (the band+tier+model family) and forget the per-query noise — the "skill of
+# remembering" applied to governance trade-offs. In-memory ring (bounded), no PII.
+# ---------------------------------------------------------------------------
+_SKELETONS: dict[str, dict[str, Any]] = {}
+
+
+def _learn_skeleton(decision: dict[str, Any]) -> None:
+    band = decision["risk"]["risk_band"]
+    tier = decision["tier"]["tier"]
+    airgap = decision["airgap_required"]
+    model_fam = ((decision.get("chosen_model") or {}).get("id") or "—").split("-")[0]
+    key = f"{band}|{tier}|{'airgap' if airgap else 'cloud'}|{model_fam}"
+    sk = _SKELETONS.get(key)
+    if sk is None:
+        sk = {
+            "key": key, "risk_band": band, "tier": tier,
+            "airgap": airgap, "model_family": model_fam,
+            "uses": 0, "first_seen": time.time(), "last_seen": time.time(),
+            "lesson": _lesson(band, tier, airgap),
+        }
+        _SKELETONS[key] = sk
+    sk["uses"] += 1
+    sk["last_seen"] = time.time()
+    # Bound the meta-memory: keep the 64 most-used skeletons (forget the rest).
+    if len(_SKELETONS) > 64:
+        worst = min(_SKELETONS.values(), key=lambda s: (s["uses"], s["last_seen"]))
+        _SKELETONS.pop(worst["key"], None)
+
+
+def _lesson(band: str, tier: str, airgap: bool) -> str:
+    z = "air-gapped (classified)" if airgap else "cloud-eligible"
+    return (f"{band}-risk decisions routed to the {tier} budget tier on {z} compute "
+            f"resolved within budget; reuse this skeleton for the same risk class.")
+
+
+def skeletons() -> dict[str, Any]:
+    sks = sorted(_SKELETONS.values(), key=lambda s: s["uses"], reverse=True)
+    return {"skeleton_count": len(sks), "skeletons": sks,
+            "hint": None if sks else "no skeletons yet — route decisions via POST /api/a11oy/v1/budget/route to learn them"}
+
+
+def register(app: FastAPI, ns: str = "a11oy") -> str:
+    @app.get(f"/api/{ns}/v1/budget/tiers", include_in_schema=False)
+    async def _tiers() -> JSONResponse:
+        return JSONResponse({"doctrine": DOCTRINE, "tiers": TIERS,
+                             "pattern_source": "ViktorAxelsen/BudgetMem (Apache-2.0) — module budget tiers, evolved to mission constraints"})
+
+    @app.post(f"/api/{ns}/v1/budget/route", include_in_schema=False)
+    async def _route(request: Request) -> JSONResponse:
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+        q = (body or {}).get("query") or (body or {}).get("q") or ""
+        declared = (body or {}).get("classification")
+        dl = (body or {}).get("deadline_s")
+        try:
+            dl = float(dl) if dl is not None else None
+        except Exception:
+            dl = None
+        if not q:
+            return JSONResponse({"error": "provide {query: ...}"}, status_code=400)
+        return JSONResponse({"doctrine": DOCTRINE, **route(q, declared=declared, deadline_s=dl)})
+
+    @app.get(f"/api/{ns}/v1/budget/skeletons", include_in_schema=False)
+    async def _sk() -> JSONResponse:
+        return JSONResponse({"doctrine": DOCTRINE, **skeletons(),
+                             "pattern_source": "ViktorAxelsen/MemSkill (Apache-2.0) — meta-memory, evolved to Decision Skeletons"})
+
+    @app.get("/budget-router", include_in_schema=False)
+    async def _page() -> HTMLResponse:
+        return HTMLResponse(_PAGE_HTML)
+
+    return f"budget-router mounted: GET /budget-router + /api/{ns}/v1/budget/(tiers|route|skeletons)"
+
+
+_PAGE_HTML = """<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>a11oy · Budget-Tier Router + Decision Skeletons</title>
+<style>
+:root{--bg:#0b0f14;--panel:#121922;--ink:#e8eef5;--muted:#8aa0b4;--gold:#d9b46a;
+--green:#3fb950;--blue:#1f6feb;--red:#f85149;--amber:#d29922;--line:#1e2a36;}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);
+font:15px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+.wrap{max-width:980px;margin:0 auto;padding:24px 18px 64px}
+h1{font-size:24px;margin:.2em 0}.sub{color:var(--muted);margin:0 0 18px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:16px;margin:14px 0}
+.row{display:flex;gap:10px;flex-wrap:wrap;align-items:center}
+input,select{background:#0d141c;border:1px solid var(--line);border-radius:8px;color:var(--ink);padding:9px 11px;font-size:14px}
+input{flex:1;min-width:200px}
+button{background:var(--gold);color:#1a1205;border:0;border-radius:8px;padding:9px 16px;font-weight:700;cursor:pointer}
+button:hover{filter:brightness(1.08)}
+.pill{display:inline-block;padding:2px 9px;border-radius:999px;font-size:12px;font-weight:600}
+.green{background:rgba(63,185,80,.15);color:var(--green)}
+.blue{background:rgba(31,111,235,.18);color:#79b8ff}
+.red{background:rgba(248,81,73,.15);color:var(--red)}
+.amber{background:rgba(210,153,34,.15);color:var(--amber)}
+.tiers{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:12px;margin-top:6px}
+.tcard{background:#0d141c;border:1px solid var(--line);border-radius:10px;padding:12px}
+.tcard h3{margin:.1em 0;font-size:16px}
+pre{background:#0d141c;border:1px solid var(--line);border-radius:8px;padding:12px;overflow:auto;font-size:12.5px;white-space:pre-wrap}
+.foot{color:var(--muted);font-size:12px;margin-top:24px;border-top:1px solid var(--line);padding-top:12px}
+code{color:var(--gold)}
+.sk{border-top:1px solid var(--line);padding:10px 0}.sk:first-child{border-top:0}
+.sk .k{color:var(--gold);font-weight:700}.sk .l{color:var(--muted);font-size:13px}
+.uses{float:right;color:var(--green);font-variant-numeric:tabular-nums}
+.chips{margin-top:10px}.chip{display:inline-block;margin:2px 4px 2px 0;padding:4px 10px;border:1px solid var(--line);
+border-radius:999px;font-size:12px;color:var(--muted);cursor:pointer;background:#0d141c}.chip:hover{border-color:var(--gold);color:var(--gold)}
+</style></head>
+<body><div class="wrap">
+<h1>Budget-Tier Router <span class="pill green">cost-aware</span> <span class="pill blue">Decision Skeletons</span></h1>
+<p class="sub">Routes each governed decision by <b>risk</b> (sensitivity × reversibility) to the
+cheapest mission budget tier that still satisfies it — <b>Tactical (≤1s)</b>, <b>Operational (≤10s)</b>,
+<b>Strategic (≤1min)</b> — then to the smallest sufficient air-gap-safe model. Patterns from
+<code>BudgetMem</code> + <code>MemSkill</code> (Apache-2.0) and <code>GraphPlanner</code> (MIT),
+evolved into mission-bound budget routing with reusable Decision Skeletons. 0 CDN.</p>
+
+<div class="card">
+<h3 style="margin-top:0">Mission budget tiers</h3>
+<div class="tiers" id="tiers"></div>
+</div>
+
+<div class="card">
+<h3 style="margin-top:0">Route a decision</h3>
+<div class="row">
+<input id="q" placeholder="describe the decision (e.g. authorize drone strike on classified grid ref)…"/>
+<select id="cls"><option value="">auto-classify</option><option>PUBLIC</option><option>INTERNAL</option><option>RESTRICTED</option><option>SECRET</option></select>
+<select id="dl"><option value="">no deadline</option><option value="1">≤1s</option><option value="10">≤10s</option><option value="60">≤60s</option></select>
+<button id="go">Route</button>
+</div>
+<div class="chips" id="chips">
+<span class="chip">summarize today's maritime intel feed</span>
+<span class="chip">authorize a drone strike on classified grid ref</span>
+<span class="chip">draft an internal roadmap memo</span>
+</div>
+<pre id="out" style="margin-top:12px">Route a decision to see the tier + model + risk verdict.</pre>
+</div>
+
+<div class="card">
+<div class="row" style="justify-content:space-between"><h3 style="margin:0">Decision Skeletons (learned)</h3>
+<button id="ref" style="background:#1f6feb;color:#fff">Refresh</button></div>
+<div id="sks" style="margin-top:8px">No skeletons yet.</div>
+</div>
+
+<p class="foot">a11oy · Doctrine v11 LOCKED 749/14/163 · Λ = Conjecture 1 ·
+patterns: BudgetMem + MemSkill (Apache-2.0), GraphPlanner (MIT), evolved · sovereign 0-CDN.</p>
+</div>
+<script>
+const $=s=>document.querySelector(s);
+function band(b){return b==='HIGH'?'red':b==='MODERATE'?'amber':'green'}
+async function tiers(){
+  const d=await(await fetch('/api/a11oy/v1/budget/tiers')).json();
+  const box=$('#tiers');box.innerHTML='';
+  for(const t of d.tiers){
+    const el=document.createElement('div');el.className='tcard';
+    el.innerHTML='<h3>'+t.tier+' <span class="pill blue">'+t.budget+'</span></h3>'
+      +'<div class="l" style="color:var(--muted);font-size:13px">deadline ≤'+t.deadline_s+'s · max model '+t.max_model_tier+' · CoT '+t.cot+'</div>'
+      +'<div style="margin-top:6px;font-size:13px">'+t.note+'</div>';
+    box.appendChild(el);
+  }
+}
+async function route(){
+  const q=$('#q').value;if(!q)return;
+  const body={query:q};const c=$('#cls').value;const dl=$('#dl').value;
+  if(c)body.classification=c;if(dl)body.deadline_s=Number(dl);
+  const d=await(await fetch('/api/a11oy/v1/budget/route',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(body)})).json();
+  const r=d.risk||{};const m=d.chosen_model;
+  $('#out').textContent=
+    'TIER: '+(d.tier&&d.tier.tier)+'  (budget '+(d.tier&&d.tier.budget)+', deadline ≤'+(d.tier&&d.tier.deadline_s)+'s)\\n'
+    +'RISK: '+r.risk+'  ['+r.risk_band+']  sensitivity='+(r.sensitivity&&r.sensitivity.class)
+    +'  reversibility='+(r.reversibility&&r.reversibility.label)+(r.capped_by_deadline?'  (tier capped by deadline)':'')+'\\n'
+    +'AIR-GAP REQUIRED: '+d.airgap_required+'\\n'
+    +'MODEL: '+(m?(m.id+'  ['+m.tier+'/'+m.zone+', '+m.license+']'):('— '+(d.honest||'')))+'\\n\\n'
+    +'policy: '+d.policy;
+  loadSk();
+}
+async function loadSk(){
+  const d=await(await fetch('/api/a11oy/v1/budget/skeletons')).json();
+  const box=$('#sks');box.innerHTML='';
+  if(!d.skeletons.length){box.innerHTML='<div class="l">'+(d.hint||'No skeletons yet.')+'</div>';return}
+  for(const s of d.skeletons){
+    const el=document.createElement('div');el.className='sk';
+    el.innerHTML='<span class="uses">×'+s.uses+'</span>'
+      +'<div class="k">'+s.key+'</div><div class="l">'+s.lesson+'</div>';
+    box.appendChild(el);
+  }
+}
+$('#go').addEventListener('click',route);
+$('#q').addEventListener('keydown',e=>{if(e.key==='Enter')route()});
+$('#ref').addEventListener('click',loadSk);
+document.querySelectorAll('.chip').forEach(c=>c.addEventListener('click',()=>{$('#q').value=c.textContent;route();}));
+tiers();loadSk();
+</script>
+</body></html>"""

szl_consensus_clusters.py

@@ -0,0 +1,306 @@
+# SPDX-License-Identifier: MIT
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+# Authored by A11oy Full-Stack Team. Co-Authored-By: Perplexity Computer Agent.
+#
+# THIRD-PARTY PATTERN ADOPTION (fashion-thinking, NOTICE attribution):
+#   ngraph.leiden — anvaka/ngraph.leiden — MIT License —
+#   https://github.com/anvaka/ngraph.leiden
+#   We adopt the PATTERN of fast, DETERMINISTIC community detection (Leiden/Louvain
+#   modularity optimization) on a graph. We EVOLVE it from a generic graph utility
+#   into "Consensus Clusters": we build a similarity graph over the substrate's
+#   governed DECISION NODES (edges weighted by shared sensitivity class, mission
+#   tier and chosen-model family) and run a clean-room Louvain modularity optimizer
+#   to surface clusters of mutually-reinforcing decisions — and the isolated
+#   OUTLIERS that warrant operator attention. Original, dependency-free
+#   implementation (no ngraph/JS source, no torch/numpy). Rendered with the
+#   ALREADY-VENDORED cytoscape.min.js (/vendor/*, 0 CDN). Λ = Conjecture 1.
+"""szl_consensus_clusters — ADDITIVE decision-node clustering tab + API.
+
+Endpoints (mounted before the SPA catch-all):
+  GET  /consensus-clusters                          — operator tab (HTML, cytoscape 0 CDN)
+  GET  /api/a11oy/v1/clusters/graph                  — clustered decision graph (cytoscape elements)
+  GET  /api/a11oy/v1/clusters/summary                — modularity, cluster sizes, outliers
+
+Decision nodes come from the REAL governance Khipu chain (szl_khipu). If no
+decisions exist yet, a small in-substrate seed graph (the doctrine relationships)
+is clustered so the algorithm is demonstrably real. Doctrine v11 LOCKED 749/14/163.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+
+DOCTRINE = {"version": "v11", "counts": "749/14/163", "lambda": "Conjecture 1"}
+
+
+# ---------------------------------------------------------------------------
+# Build a weighted similarity graph over governed decisions.
+# ---------------------------------------------------------------------------
+def _decision_nodes() -> list[dict[str, Any]]:
+    nodes: list[dict[str, Any]] = []
+    try:
+        import szl_khipu  # type: ignore
+        dag = szl_khipu.get_dag("governance-gateway", ns="a11oy")
+        for r in dag.tail(200):
+            nodes.append({
+                "id": (r.get("digest") or "")[:16] or f"seq{r.get('seq')}",
+                "label": f"#{r.get('seq','?')}",
+                "sens": str(r.get("sensitivity") or r.get("class") or "PUBLIC"),
+                "tier": str(r.get("min_tier") or r.get("zone") or "T?"),
+                "model": str(r.get("chosen") or "—"),
+            })
+    except Exception:
+        pass
+    if nodes:
+        return nodes
+    # Honest seed: the substrate's own doctrine relationships (so clustering is real
+    # even before decisions are driven). Three natural families.
+    return [
+        {"id": "d-airgap", "label": "air-gap", "sens": "SECRET", "tier": "T2", "model": "olmo"},
+        {"id": "d-classified", "label": "classified", "sens": "SECRET", "tier": "T2", "model": "deepseek"},
+        {"id": "d-restricted", "label": "restricted", "sens": "RESTRICTED", "tier": "T1", "model": "qwen3"},
+        {"id": "d-internal", "label": "internal", "sens": "INTERNAL", "tier": "T2", "model": "claude"},
+        {"id": "d-roadmap", "label": "roadmap", "sens": "INTERNAL", "tier": "T2", "model": "claude"},
+        {"id": "d-public", "label": "public", "sens": "PUBLIC", "tier": "T5", "model": "gemini"},
+        {"id": "d-triage", "label": "triage", "sens": "PUBLIC", "tier": "T1", "model": "qwen3"},
+        {"id": "d-research", "label": "research", "sens": "PUBLIC", "tier": "T5", "model": "gemini"},
+    ]
+
+
+def _build_weighted_graph() -> tuple[list[dict[str, Any]], dict[tuple[str, str], float]]:
+    nodes = _decision_nodes()
+    weights: dict[tuple[str, str], float] = {}
+    for i in range(len(nodes)):
+        for j in range(i + 1, len(nodes)):
+            a, b = nodes[i], nodes[j]
+            w = 0.0
+            if a["sens"] == b["sens"]:
+                w += 1.5
+            if a["tier"] == b["tier"]:
+                w += 1.0
+            if a["model"] == b["model"] and a["model"] != "—":
+                w += 1.0
+            if w > 0:
+                weights[(a["id"], b["id"])] = w
+    return nodes, weights
+
+
+# ---------------------------------------------------------------------------
+# Clean-room Louvain modularity optimization (deterministic single pass + refine).
+# ---------------------------------------------------------------------------
+def _louvain(nodes: list[dict[str, Any]],
+             weights: dict[tuple[str, str], float]) -> dict[str, int]:
+    ids = [n["id"] for n in nodes]
+    adj: dict[str, dict[str, float]] = {i: {} for i in ids}
+    m2 = 0.0  # 2m (sum of all edge weights, counted once per pair → 2x in degree sums)
+    for (u, v), w in weights.items():
+        adj[u][v] = adj[u].get(v, 0.0) + w
+        adj[v][u] = adj[v].get(u, 0.0) + w
+        m2 += 2 * w
+    if m2 == 0:
+        return {i: idx for idx, i in enumerate(ids)}
+    k = {i: sum(adj[i].values()) for i in ids}
+    comm = {i: idx for idx, i in enumerate(ids)}  # start: singleton communities
+    sigma_tot: dict[int, float] = {idx: k[i] for idx, i in enumerate(ids)}
+
+    improved = True
+    passes = 0
+    while improved and passes < 20:
+        improved = False
+        passes += 1
+        for i in ids:
+            ci = comm[i]
+            # remove i from its community
+            sigma_tot[ci] -= k[i]
+            # weight from i to each neighboring community
+            wj: dict[int, float] = {}
+            for j, w in adj[i].items():
+                wj[comm[j]] = wj.get(comm[j], 0.0) + w
+            best_c, best_gain = ci, 0.0
+            for c, wic in wj.items():
+                gain = wic - sigma_tot.get(c, 0.0) * k[i] / m2
+                if gain > best_gain:
+                    best_gain, best_c = gain, c
+            # also consider staying (gain of own community already removed)
+            comm[i] = best_c
+            sigma_tot[best_c] = sigma_tot.get(best_c, 0.0) + k[i]
+            if best_c != ci:
+                improved = True
+    # relabel communities 0..N-1 deterministically
+    relabel: dict[int, int] = {}
+    for i in ids:
+        c = comm[i]
+        if c not in relabel:
+            relabel[c] = len(relabel)
+        comm[i] = relabel[c]
+    return comm
+
+
+def _modularity(nodes, weights, comm) -> float:
+    ids = [n["id"] for n in nodes]
+    m2 = 2 * sum(weights.values())
+    if m2 == 0:
+        return 0.0
+    k: dict[str, float] = {i: 0.0 for i in ids}
+    for (u, v), w in weights.items():
+        k[u] += w
+        k[v] += w
+    q = 0.0
+    for (u, v), w in weights.items():
+        if comm[u] == comm[v]:
+            q += 2 * (w - k[u] * k[v] / m2)
+    # diagonal (self) terms are zero here (no self-loops)
+    return round(q / m2, 4)
+
+
+_PALETTE = ["#3fb950", "#1f6feb", "#d9b46a", "#f85149", "#a371f7", "#db61a2", "#56d4dd", "#e3b341"]
+
+
+def build_graph() -> dict[str, Any]:
+    nodes, weights = _build_weighted_graph()
+    comm = _louvain(nodes, weights)
+    cy_nodes = []
+    for n in nodes:
+        c = comm[n["id"]]
+        cy_nodes.append({"data": {
+            "id": n["id"], "label": n["label"], "cluster": c,
+            "color": _PALETTE[c % len(_PALETTE)],
+            "sens": n["sens"], "tier": n["tier"], "model": n["model"]}})
+    cy_edges = []
+    for (u, v), w in weights.items():
+        intra = comm[u] == comm[v]
+        cy_edges.append({"data": {
+            "id": f"e-{u}-{v}", "source": u, "target": v,
+            "weight": w, "intra": intra}})
+    return {"nodes": cy_nodes, "edges": cy_edges, "communities": comm,
+            "node_count": len(cy_nodes), "edge_count": len(cy_edges)}
+
+
+def summarize() -> dict[str, Any]:
+    nodes, weights = _build_weighted_graph()
+    comm = _louvain(nodes, weights)
+    sizes: dict[int, int] = {}
+    for c in comm.values():
+        sizes[c] = sizes.get(c, 0) + 1
+    outliers = [nid for nid, c in comm.items() if sizes[c] == 1]
+    q = _modularity(nodes, weights, comm)
+    seeded = not _has_live_decisions()
+    return {
+        "node_count": len(nodes), "edge_count": len(weights),
+        "cluster_count": len(sizes), "modularity": q,
+        "cluster_sizes": [{"cluster": c, "size": s} for c, s in sorted(sizes.items())],
+        "consensus_clusters": sum(1 for s in sizes.values() if s >= 2),
+        "outliers": outliers,
+        "algorithm": "Louvain modularity optimization (clean-room, deterministic), evolved from anvaka/ngraph.leiden (MIT)",
+        "seeded": seeded,
+        "hint": ("clustering the in-substrate doctrine seed graph — drive /governance-gateway to cluster real decisions"
+                 if seeded else None),
+    }
+
+
+def _has_live_decisions() -> bool:
+    try:
+        import szl_khipu  # type: ignore
+        dag = szl_khipu.get_dag("governance-gateway", ns="a11oy")
+        return len(dag.tail(1)) > 0
+    except Exception:
+        return False
+
+
+def register(app: FastAPI, ns: str = "a11oy") -> str:
+    @app.get(f"/api/{ns}/v1/clusters/graph", include_in_schema=False)
+    async def _graph() -> JSONResponse:
+        g = build_graph()
+        return JSONResponse({"doctrine": DOCTRINE, "nodes": g["nodes"], "edges": g["edges"],
+                             "node_count": g["node_count"], "edge_count": g["edge_count"],
+                             "pattern_source": "anvaka/ngraph.leiden (MIT) — community detection, evolved to consensus clusters"})
+
+    @app.get(f"/api/{ns}/v1/clusters/summary", include_in_schema=False)
+    async def _summary() -> JSONResponse:
+        return JSONResponse({"doctrine": DOCTRINE, **summarize()})
+
+    @app.get("/consensus-clusters", include_in_schema=False)
+    async def _page() -> HTMLResponse:
+        return HTMLResponse(_PAGE_HTML)
+
+    return f"consensus-clusters mounted: GET /consensus-clusters + /api/{ns}/v1/clusters/(graph|summary)"
+
+
+_PAGE_HTML = """<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>a11oy · Consensus Clusters</title>
+<script src="/vendor/cytoscape.min.js"></script>
+<style>
+:root{--bg:#0b0f14;--panel:#121922;--ink:#e8eef5;--muted:#8aa0b4;--gold:#d9b46a;
+--green:#3fb950;--blue:#1f6feb;--line:#1e2a36;}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);
+font:15px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+.wrap{max-width:1080px;margin:0 auto;padding:24px 18px 64px}
+h1{font-size:24px;margin:.2em 0}.sub{color:var(--muted);margin:0 0 18px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:16px;margin:14px 0}
+.row{display:flex;gap:12px;flex-wrap:wrap;align-items:center}
+button{background:var(--gold);color:#1a1205;border:0;border-radius:8px;padding:9px 16px;font-weight:700;cursor:pointer}
+button:hover{filter:brightness(1.08)}
+#cy{width:100%;height:460px;background:#0d141c;border:1px solid var(--line);border-radius:10px}
+.pill{display:inline-block;padding:2px 9px;border-radius:999px;font-size:12px;font-weight:600}
+.green{background:rgba(63,185,80,.15);color:var(--green)}
+.blue{background:rgba(31,111,235,.18);color:#79b8ff}
+pre{background:#0d141c;border:1px solid var(--line);border-radius:8px;padding:12px;overflow:auto;font-size:12.5px;white-space:pre-wrap}
+.foot{color:var(--muted);font-size:12px;margin-top:24px;border-top:1px solid var(--line);padding-top:12px}
+code{color:var(--gold)}
+</style></head>
+<body><div class="wrap">
+<h1>Consensus Clusters <span class="pill blue">Louvain</span></h1>
+<p class="sub">Builds a similarity graph over governed <b>decision nodes</b> (edges weighted by shared
+sensitivity, mission tier and model family) and runs modularity optimization to surface
+<b>consensus clusters</b> of mutually-reinforcing decisions — and the isolated <b>outliers</b>
+worth an operator's attention. Pattern from <code>anvaka/ngraph.leiden</code> (MIT), evolved.
+Rendered with vendored cytoscape (0&nbsp;CDN).</p>
+
+<div class="card">
+<div class="row" style="justify-content:space-between">
+<div id="legend" class="row"></div>
+<button id="ref">Recompute clusters</button>
+</div>
+<div id="cy" style="margin-top:12px"></div>
+<pre id="sum" style="margin-top:12px">Computing communities…</pre>
+</div>
+
+<p class="foot">a11oy · Doctrine v11 LOCKED 749/14/163 · Λ = Conjecture 1 ·
+pattern: anvaka/ngraph.leiden (MIT), evolved · sovereign 0-CDN (vendored cytoscape).</p>
+</div>
+<script>
+const $=s=>document.querySelector(s);
+let cy=null;
+async function load(){
+  const g=await(await fetch('/api/a11oy/v1/clusters/graph')).json();
+  const s=await(await fetch('/api/a11oy/v1/clusters/summary')).json();
+  if(cy)cy.destroy();
+  cy=cytoscape({container:$('#cy'),elements:[].concat(g.nodes,g.edges),
+    style:[
+      {selector:'node',style:{'background-color':'data(color)','label':'data(label)',
+        'color':'#e8eef5','font-size':'10px','text-valign':'top','width':24,'height':24,
+        'border-width':2,'border-color':'#0b0f14'}},
+      {selector:'edge[?intra]',style:{'line-color':'#3fb950','width':'mapData(weight,0,3,1,5)','opacity':0.7,'curve-style':'haystack'}},
+      {selector:'edge[!intra]',style:{'line-color':'#33425a','width':1,'opacity':0.35,'line-style':'dotted','curve-style':'haystack'}}
+    ],
+    layout:{name:'cose',animate:false,padding:24,nodeRepulsion:9000,idealEdgeLength:70}});
+  const leg=$('#legend');leg.innerHTML='';
+  const colors=[...new Set(g.nodes.map(n=>n.data.color))];
+  colors.forEach((c,i)=>{const sp=document.createElement('span');sp.className='pill';
+    sp.style.background=c+'33';sp.style.color=c;sp.textContent='cluster '+i;leg.appendChild(sp);
+    leg.appendChild(document.createTextNode(' '));});
+  $('#sum').textContent='nodes='+s.node_count+'  edges='+s.edge_count
+    +'  clusters='+s.cluster_count+'  modularity Q='+s.modularity
+    +'  consensus_clusters='+s.consensus_clusters+'  outliers='+(s.outliers.length)
+    +'\\n'+s.algorithm+(s.seeded?('\\n\\nNOTE: '+s.hint):'')
+    +'\\n\\ncluster sizes:\\n'+JSON.stringify(s.cluster_sizes,null,2)
+    +(s.outliers.length?('\\noutliers: '+s.outliers.join(', ')):'');
+}
+$('#ref').addEventListener('click',load);
+load();
+</script>
+</body></html>"""

szl_mission_ledger.py

@@ -0,0 +1,217 @@
+# SPDX-License-Identifier: MIT
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+# Authored by A11oy Full-Stack Team. Co-Authored-By: Perplexity Computer Agent.
+#
+# THIRD-PARTY PATTERN ADOPTION (fashion-thinking, NOTICE attribution):
+#   research-arcade — ulab-uiuc/research-arcade — MIT License —
+#   https://github.com/ulab-uiuc/research-arcade
+#   We adopt the PATTERN of a HETEROGENEOUS GRAPH interface that unifies disparate
+#   structured sources (papers, reviews, authors) into one graph with typed nodes
+#   and graph-like CRUD. We EVOLVE it into a live "Mission Ledger": a heterogeneous
+#   knowledge graph over THREE a11oy node types — DOCUMENTS (governed source
+#   material), OBJECTIVES (mission goals) and DECISIONS (governed AI outputs, drawn
+#   from the real Khipu chain) — with typed edges (cites, supports, resulted_in) so
+#   the provenance from source material → mission objective → governed action is
+#   explicit and auditable. Original, dependency-free implementation (no
+#   research-arcade source, no SQL backend, no torch/numpy). Rendered with the
+#   ALREADY-VENDORED cytoscape.min.js (/vendor/*, 0 CDN). Λ = Conjecture 1.
+"""szl_mission_ledger — ADDITIVE heterogeneous knowledge-graph tab + API.
+
+Endpoints (mounted before the SPA catch-all):
+  GET  /mission-ledger                              — operator tab (HTML, cytoscape 0 CDN)
+  GET  /api/a11oy/v1/ledger/graph                    — heterogeneous KG (cytoscape elements)
+  GET  /api/a11oy/v1/ledger/summary                  — node/edge type counts, coverage
+
+DECISION nodes are pulled from the REAL governance Khipu chain when present and
+linked into the document/objective scaffold. Doctrine v11 LOCKED 749/14/163.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+
+DOCTRINE = {"version": "v11", "counts": "749/14/163", "lambda": "Conjecture 1"}
+
+# In-substrate scaffold: documents + objectives (the governed mission context).
+# These are real a11oy doctrine artifacts; decisions are appended from the live chain.
+_DOCUMENTS = [
+    {"id": "doc-roe", "label": "Rules of Engagement", "type": "document", "tag": "RESTRICTED"},
+    {"id": "doc-airgap", "label": "Air-Gap Sovereignty Spec", "type": "document", "tag": "doctrine"},
+    {"id": "doc-intel", "label": "Maritime Intel Brief", "type": "document", "tag": "RESTRICTED"},
+    {"id": "doc-policy", "label": "Governance Policy Manifest", "type": "document", "tag": "doctrine"},
+]
+_OBJECTIVES = [
+    {"id": "obj-sovereign", "label": "Run classified decisions air-gapped", "type": "objective"},
+    {"id": "obj-audit", "label": "Keep every decision tamper-evident", "type": "objective"},
+    {"id": "obj-cost", "label": "Minimize compute on time-critical calls", "type": "objective"},
+]
+# Static provenance edges in the scaffold (documents → objectives).
+_SCAFFOLD_EDGES = [
+    ("doc-roe", "obj-sovereign", "supports"),
+    ("doc-airgap", "obj-sovereign", "cites"),
+    ("doc-intel", "obj-sovereign", "supports"),
+    ("doc-policy", "obj-audit", "cites"),
+    ("doc-policy", "obj-cost", "supports"),
+]
+# Which objective a decision serves, inferred from its governance fields.
+def _objective_for(rec: dict[str, Any]) -> str:
+    sens = str(rec.get("sensitivity") or rec.get("class") or "").upper()
+    if sens in ("RESTRICTED", "SECRET") or rec.get("airgap_required"):
+        return "obj-sovereign"
+    if str(rec.get("min_tier") or "").upper() in ("T0", "T1"):
+        return "obj-cost"
+    return "obj-audit"
+
+
+def _decisions() -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    try:
+        import szl_khipu  # type: ignore
+        dag = szl_khipu.get_dag("governance-gateway", ns="a11oy")
+        for r in dag.tail(60):
+            out.append(r)
+    except Exception:
+        pass
+    return out
+
+
+def build_graph() -> dict[str, Any]:
+    nodes: list[dict[str, Any]] = []
+    edges: list[dict[str, Any]] = []
+    for d in _DOCUMENTS:
+        nodes.append({"data": {**d}})
+    for o in _OBJECTIVES:
+        nodes.append({"data": {**o}})
+    for (s, t, rel) in _SCAFFOLD_EDGES:
+        edges.append({"data": {"id": f"e-{s}-{t}", "source": s, "target": t, "rel": rel}})
+
+    decs = _decisions()
+    for r in decs:
+        did = "dec-" + ((r.get("digest") or "")[:12] or f"seq{r.get('seq')}")
+        nodes.append({"data": {
+            "id": did, "label": f"decision #{r.get('seq','?')}", "type": "decision",
+            "model": str(r.get("chosen") or "—"), "sens": str(r.get("sensitivity") or "?")}})
+        obj = _objective_for(r)
+        edges.append({"data": {"id": f"e-{did}-{obj}", "source": obj, "target": did, "rel": "resulted_in"}})
+
+    return {"nodes": nodes, "edges": edges,
+            "node_count": len(nodes), "edge_count": len(edges),
+            "decision_count": len(decs)}
+
+
+def summarize() -> dict[str, Any]:
+    g = build_graph()
+    by_type: dict[str, int] = {}
+    for n in g["nodes"]:
+        t = n["data"].get("type", "?")
+        by_type[t] = by_type.get(t, 0) + 1
+    by_rel: dict[str, int] = {}
+    for e in g["edges"]:
+        rl = e["data"].get("rel", "?")
+        by_rel[rl] = by_rel.get(rl, 0) + 1
+    return {
+        "node_count": g["node_count"], "edge_count": g["edge_count"],
+        "node_types": by_type, "edge_types": by_rel,
+        "decision_count": g["decision_count"],
+        "structure": "heterogeneous KG — documents → objectives → decisions",
+        "hint": (None if g["decision_count"]
+                 else "scaffold only — drive /governance-gateway to attach real decisions to the ledger"),
+    }
+
+
+def register(app: FastAPI, ns: str = "a11oy") -> str:
+    @app.get(f"/api/{ns}/v1/ledger/graph", include_in_schema=False)
+    async def _graph() -> JSONResponse:
+        g = build_graph()
+        return JSONResponse({"doctrine": DOCTRINE, **g,
+                             "pattern_source": "ulab-uiuc/research-arcade (MIT) — heterogeneous graph interface, evolved to Mission Ledger"})
+
+    @app.get(f"/api/{ns}/v1/ledger/summary", include_in_schema=False)
+    async def _summary() -> JSONResponse:
+        return JSONResponse({"doctrine": DOCTRINE, **summarize()})
+
+    @app.get("/mission-ledger", include_in_schema=False)
+    async def _page() -> HTMLResponse:
+        return HTMLResponse(_PAGE_HTML)
+
+    return f"mission-ledger mounted: GET /mission-ledger + /api/{ns}/v1/ledger/(graph|summary)"
+
+
+_PAGE_HTML = """<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>a11oy · Mission Ledger</title>
+<script src="/vendor/cytoscape.min.js"></script>
+<style>
+:root{--bg:#0b0f14;--panel:#121922;--ink:#e8eef5;--muted:#8aa0b4;--gold:#d9b46a;
+--green:#3fb950;--blue:#1f6feb;--purple:#a371f7;--line:#1e2a36;}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);
+font:15px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+.wrap{max-width:1080px;margin:0 auto;padding:24px 18px 64px}
+h1{font-size:24px;margin:.2em 0}.sub{color:var(--muted);margin:0 0 18px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:16px;margin:14px 0}
+.row{display:flex;gap:12px;flex-wrap:wrap;align-items:center}
+button{background:var(--gold);color:#1a1205;border:0;border-radius:8px;padding:9px 16px;font-weight:700;cursor:pointer}
+button:hover{filter:brightness(1.08)}
+#cy{width:100%;height:460px;background:#0d141c;border:1px solid var(--line);border-radius:10px}
+.pill{display:inline-block;padding:2px 9px;border-radius:999px;font-size:12px;font-weight:600}
+.doc{background:rgba(31,111,235,.18);color:#79b8ff}
+.obj{background:rgba(217,180,106,.18);color:var(--gold)}
+.dec{background:rgba(63,185,80,.15);color:var(--green)}
+pre{background:#0d141c;border:1px solid var(--line);border-radius:8px;padding:12px;overflow:auto;font-size:12.5px;white-space:pre-wrap}
+.foot{color:var(--muted);font-size:12px;margin-top:24px;border-top:1px solid var(--line);padding-top:12px}
+code{color:var(--gold)}
+.legend span{margin-right:6px}
+</style></head>
+<body><div class="wrap">
+<h1>Mission Ledger <span class="pill dec">knowledge graph</span></h1>
+<p class="sub">A heterogeneous knowledge graph linking <span class="pill doc">documents</span>
+(governed source material) → <span class="pill obj">objectives</span> (mission goals) →
+<span class="pill dec">decisions</span> (governed AI outputs from the real Khipu chain), with typed
+edges (<code>cites</code>, <code>supports</code>, <code>resulted_in</code>) so provenance from source
+to action is explicit. Pattern from <code>ulab-uiuc/research-arcade</code> (MIT), evolved.
+Rendered with vendored cytoscape (0&nbsp;CDN).</p>
+
+<div class="card">
+<div class="row" style="justify-content:space-between">
+<div class="legend"><span class="pill doc">document</span><span class="pill obj">objective</span><span class="pill dec">decision</span></div>
+<button id="ref">Refresh ledger</button>
+</div>
+<div id="cy" style="margin-top:12px"></div>
+<pre id="sum" style="margin-top:12px">Loading mission ledger…</pre>
+</div>
+
+<p class="foot">a11oy · Doctrine v11 LOCKED 749/14/163 · Λ = Conjecture 1 ·
+pattern: ulab-uiuc/research-arcade (MIT), evolved · sovereign 0-CDN (vendored cytoscape).</p>
+</div>
+<script>
+const $=s=>document.querySelector(s);
+let cy=null;
+const COLOR={document:'#1f6feb',objective:'#d9b46a',decision:'#3fb950'};
+async function load(){
+  const g=await(await fetch('/api/a11oy/v1/ledger/graph')).json();
+  const s=await(await fetch('/api/a11oy/v1/ledger/summary')).json();
+  if(cy)cy.destroy();
+  cy=cytoscape({container:$('#cy'),elements:[].concat(g.nodes,g.edges),
+    style:[
+      {selector:'node',style:{'background-color':ele=>COLOR[ele.data('type')]||'#888',
+        'label':'data(label)','color':'#e8eef5','font-size':'9px','text-valign':'bottom',
+        'text-margin-y':3,'width':22,'height':22}},
+      {selector:'node[type="objective"]',style:{'shape':'round-rectangle','width':30,'height':22}},
+      {selector:'node[type="decision"]',style:{'shape':'diamond'}},
+      {selector:'edge',style:{'line-color':'#33425a','width':1.6,'curve-style':'bezier',
+        'target-arrow-shape':'triangle','target-arrow-color':'#33425a','label':'data(rel)',
+        'font-size':'7px','color':'#8aa0b4','text-rotation':'autorotate'}}
+    ],
+    layout:{name:'breadthfirst',directed:true,padding:24,spacingFactor:1.25}});
+  $('#sum').textContent='nodes='+s.node_count+'  edges='+s.edge_count
+    +'  decisions='+s.decision_count+'\\nnode types: '+JSON.stringify(s.node_types)
+    +'\\nedge types: '+JSON.stringify(s.edge_types)
+    +(s.hint?('\\n\\nHINT: '+s.hint):'');
+}
+$('#ref').addEventListener('click',load);
+load();
+</script>
+</body></html>"""

szl_sovereign_search.py

@@ -0,0 +1,346 @@
+# SPDX-License-Identifier: MIT
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+# Authored by A11oy Full-Stack Team. Co-Authored-By: Perplexity Computer Agent.
+#
+# THIRD-PARTY PATTERN ADOPTION (fashion-thinking, NOTICE attribution):
+#   tantivy-wasm — phiresky/tantivy-wasm — MIT License —
+#   https://github.com/phiresky/tantivy-wasm
+#   We adopt the PATTERN of a SOVEREIGN, in-deployment full-text search engine that
+#   needs NO external Elasticsearch/Meilisearch service and NO network egress — the
+#   index lives with the data and queries are answered locally. tantivy-wasm proves
+#   this by running the Rust Tantivy engine in WASM and fetching index segments via
+#   HTTP range requests. We EVOLVE the IDEA into a dependency-free, stdlib-only
+#   server-side BM25 engine that indexes the a11oy GOVERNANCE CORPUS (decision
+#   receipts, model catalog, doctrine docs, gates manifest) so an operator can run
+#   sub-second relevance search over the entire governed-AI substrate with ZERO
+#   backend service and ZERO CDN — the literal air-gap requirement. Original,
+#   clean-room implementation; no Tantivy/Rust/WASM code; no torch/numpy.
+"""szl_sovereign_search — ADDITIVE in-substrate full-text search tab + API.
+
+Endpoints (mounted before the SPA catch-all):
+  GET  /sovereign-search                           — operator tab (HTML, 0 CDN)
+  GET  /api/a11oy/v1/search/corpus                  — corpus stats (docs, terms)
+  GET  /api/a11oy/v1/search/query?q=...&k=...        — BM25 ranked results
+  GET  /api/a11oy/v1/search/reindex                  — rebuild the index from live sources
+
+The corpus is assembled from REAL a11oy substrate:
+  • the live governance model catalog (szl_governance_gateway, if present)
+  • governance decision receipts (szl_khipu DAG, if present)
+  • doctrine / disclosure snippets shipped in-image
+The BM25 ranker is a textbook Okapi BM25 (k1=1.5, b=0.75) computed over the live
+corpus — no external service. Λ = Conjecture 1. Doctrine v11 LOCKED 749/14/163.
+"""
+from __future__ import annotations
+
+import math
+import re
+import time
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+
+DOCTRINE = {"version": "v11", "counts": "749/14/163", "lambda": "Conjecture 1"}
+
+_TOKEN_RE = re.compile(r"[a-z0-9][a-z0-9\-_.]*")
+# Minimal English stop list — keeps the index lean without external NLTK data.
+_STOP = {
+    "the", "a", "an", "and", "or", "of", "to", "in", "is", "are", "for", "on",
+    "with", "as", "by", "at", "be", "this", "that", "it", "from", "we", "our",
+}
+
+
+def _tokenize(text: str) -> list[str]:
+    return [t for t in _TOKEN_RE.findall((text or "").lower()) if t not in _STOP and len(t) > 1]
+
+
+# ---------------------------------------------------------------------------
+# Corpus assembly — every document is sourced from a REAL a11oy substrate.
+# ---------------------------------------------------------------------------
+def _corpus() -> list[dict[str, Any]]:
+    docs: list[dict[str, Any]] = []
+
+    # 1) Governance model catalog (the routing decision substrate).
+    try:
+        import szl_governance_gateway as _gg  # type: ignore
+        for m in getattr(_gg, "CATALOG", []) or []:
+            docs.append({
+                "id": f"model:{m.get('id')}",
+                "kind": "model",
+                "title": f"{m.get('id')} · {m.get('tier','?')}/{m.get('zone','?')}",
+                "body": " ".join(str(v) for v in m.values()),
+                "ref": "/governance-gateway",
+            })
+    except Exception:
+        pass
+
+    # 2) Governance decision receipts (real Khipu hash-chain).
+    try:
+        import szl_khipu  # type: ignore
+        dag = szl_khipu.get_dag("governance-gateway", ns="a11oy")
+        for r in dag.tail(200):
+            docs.append({
+                "id": f"receipt:{(r.get('digest') or '')[:16]}",
+                "kind": "receipt",
+                "title": f"decision #{r.get('seq','?')} · {r.get('action','?')}",
+                "body": " ".join(str(v) for v in r.values()),
+                "ref": "/gor-audit",
+            })
+    except Exception:
+        pass
+
+    # 3) Doctrine / disclosure corpus shipped in-image (always available — gives the
+    #    search engine a non-empty corpus even before any decision is driven).
+    docs.extend(_DOCTRINE_DOCS)
+    return docs
+
+
+# Curated, in-image doctrine snippets (the substrate's own governed knowledge).
+_DOCTRINE_DOCS: list[dict[str, Any]] = [
+    {"id": "doc:airgap", "kind": "doctrine", "title": "Air-gap sovereignty floor", "ref": "/governance-gateway",
+     "body": "RESTRICTED and SECRET classified data force air-gap routing and may never leave for cloud "
+             "endpoints. The sovereign floor guarantees governed decisions on classified material run on "
+             "self-hosted, clean-lineage weights with zero network egress."},
+    {"id": "doc:khipu", "kind": "doctrine", "title": "Khipu hash-chained receipts", "ref": "/gor-audit",
+     "body": "Every governed decision is signed as a hash-chained Khipu receipt with sequence, digest and "
+             "prev-link so the entire decision history is tamper-evident and replayable for audit."},
+    {"id": "doc:lambda", "kind": "doctrine", "title": "Lambda is Conjecture 1", "ref": "/",
+     "body": "The Lambda quantity is labelled Conjecture 1 — an honest, unproven conjecture. The doctrine "
+             "locks exactly the proven formulas and never overstates the proof status of any claim."},
+    {"id": "doc:budget", "kind": "doctrine", "title": "Budget-tier decision routing", "ref": "/budget-router",
+     "body": "Mission constraints map to budget tiers: Tactical demands sub-second low-tier inference, "
+             "Operational allows mid-tier reasoning, Strategic permits high-tier chain-of-thought. The router "
+             "selects the cheapest tier that satisfies the decision risk so sovereign hardware is never choked."},
+    {"id": "doc:consensus", "kind": "doctrine", "title": "Consensus clusters of decisions", "ref": "/consensus-clusters",
+     "body": "Related governed-AI decision nodes are grouped into consensus clusters by community detection so "
+             "operators can see which decisions reinforce one another and which are isolated outliers."},
+    {"id": "doc:mission-ledger", "kind": "doctrine", "title": "Mission Ledger knowledge graph", "ref": "/mission-ledger",
+     "body": "The Mission Ledger links documents, mission objectives and the resulting AI decisions into one "
+             "heterogeneous knowledge graph so the provenance from source material to governed action is explicit."},
+]
+
+
+# ---------------------------------------------------------------------------
+# BM25 index (Okapi BM25, stdlib-only).
+# ---------------------------------------------------------------------------
+class _Bm25Index:
+    K1 = 1.5
+    B = 0.75
+
+    def __init__(self) -> None:
+        self.docs: list[dict[str, Any]] = []
+        self.tokens: list[list[str]] = []
+        self.df: dict[str, int] = {}
+        self.avgdl: float = 0.0
+        self.built_at: float = 0.0
+
+    def build(self) -> None:
+        self.docs = _corpus()
+        self.tokens = [_tokenize(d["title"] + " " + d["body"]) for d in self.docs]
+        self.df = {}
+        for toks in self.tokens:
+            for t in set(toks):
+                self.df[t] = self.df.get(t, 0) + 1
+        n = len(self.tokens)
+        self.avgdl = (sum(len(t) for t in self.tokens) / n) if n else 0.0
+        self.built_at = time.time()
+
+    def _idf(self, term: str) -> float:
+        n = len(self.docs)
+        df = self.df.get(term, 0)
+        # BM25 idf with +1 to keep it non-negative.
+        return math.log(1 + (n - df + 0.5) / (df + 0.5))
+
+    def query(self, q: str, k: int = 8) -> list[dict[str, Any]]:
+        qterms = _tokenize(q)
+        if not qterms or not self.docs:
+            return []
+        scored: list[tuple[float, int, list[str]]] = []
+        for i, toks in enumerate(self.tokens):
+            if not toks:
+                continue
+            tf: dict[str, int] = {}
+            for t in toks:
+                tf[t] = tf.get(t, 0) + 1
+            dl = len(toks)
+            score = 0.0
+            hits: list[str] = []
+            for term in qterms:
+                f = tf.get(term, 0)
+                if f == 0:
+                    continue
+                hits.append(term)
+                idf = self._idf(term)
+                denom = f + self.K1 * (1 - self.B + self.B * dl / (self.avgdl or 1))
+                score += idf * (f * (self.K1 + 1)) / (denom or 1)
+            if score > 0:
+                scored.append((score, i, hits))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        out: list[dict[str, Any]] = []
+        for score, i, hits in scored[:k]:
+            d = self.docs[i]
+            out.append({
+                "id": d["id"], "kind": d["kind"], "title": d["title"], "ref": d.get("ref"),
+                "score": round(score, 4), "matched_terms": hits,
+                "snippet": _snippet(d["body"], hits),
+            })
+        return out
+
+    def stats(self) -> dict[str, Any]:
+        kinds: dict[str, int] = {}
+        for d in self.docs:
+            kinds[d["kind"]] = kinds.get(d["kind"], 0) + 1
+        return {
+            "doc_count": len(self.docs),
+            "unique_terms": len(self.df),
+            "avg_doc_len": round(self.avgdl, 2),
+            "by_kind": kinds,
+            "built_at": self.built_at,
+            "ranker": "Okapi BM25 (k1=1.5, b=0.75), stdlib-only, 0 service",
+        }
+
+
+def _snippet(body: str, hits: list[str]) -> str:
+    low = body.lower()
+    pos = -1
+    for h in hits:
+        p = low.find(h)
+        if p >= 0:
+            pos = p
+            break
+    if pos < 0:
+        return body[:160]
+    start = max(0, pos - 60)
+    return ("…" if start else "") + body[start:start + 200] + ("…" if start + 200 < len(body) else "")
+
+
+_INDEX = _Bm25Index()
+
+
+def register(app: FastAPI, ns: str = "a11oy") -> str:
+    _INDEX.build()
+
+    @app.get(f"/api/{ns}/v1/search/corpus", include_in_schema=False)
+    async def _corpus_stats() -> JSONResponse:
+        if not _INDEX.docs:
+            _INDEX.build()
+        return JSONResponse({"doctrine": DOCTRINE, **_INDEX.stats(),
+                             "pattern_source": "phiresky/tantivy-wasm (MIT) — sovereign in-deployment search, evolved to stdlib BM25"})
+
+    @app.get(f"/api/{ns}/v1/search/query", include_in_schema=False)
+    async def _query(q: str = "", k: int = 8) -> JSONResponse:
+        if not _INDEX.docs:
+            _INDEX.build()
+        k = max(1, min(int(k or 8), 25))
+        results = _INDEX.query(q, k)
+        return JSONResponse({"doctrine": DOCTRINE, "query": q, "k": k,
+                             "result_count": len(results), "results": results})
+
+    @app.get(f"/api/{ns}/v1/search/reindex", include_in_schema=False)
+    async def _reindex() -> JSONResponse:
+        _INDEX.build()
+        return JSONResponse({"doctrine": DOCTRINE, "reindexed": True, **_INDEX.stats()})
+
+    @app.get("/sovereign-search", include_in_schema=False)
+    async def _page() -> HTMLResponse:
+        return HTMLResponse(_PAGE_HTML)
+
+    return f"sovereign-search mounted: GET /sovereign-search + /api/{ns}/v1/search/(corpus|query|reindex)"
+
+
+_PAGE_HTML = """<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>a11oy · Sovereign Corpus Search</title>
+<style>
+:root{--bg:#0b0f14;--panel:#121922;--ink:#e8eef5;--muted:#8aa0b4;--gold:#d9b46a;
+--green:#3fb950;--blue:#1f6feb;--line:#1e2a36;}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);
+font:15px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+.wrap{max-width:920px;margin:0 auto;padding:24px 18px 64px}
+h1{font-size:24px;margin:.2em 0}.sub{color:var(--muted);margin:0 0 18px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:16px;margin:14px 0}
+.row{display:flex;gap:10px;flex-wrap:wrap;align-items:center}
+input{flex:1;min-width:200px;background:#0d141c;border:1px solid var(--line);border-radius:8px;
+color:var(--ink);padding:10px 12px;font-size:15px}
+button{background:var(--gold);color:#1a1205;border:0;border-radius:8px;padding:10px 16px;font-weight:700;cursor:pointer}
+button:hover{filter:brightness(1.08)}
+.pill{display:inline-block;padding:2px 9px;border-radius:999px;font-size:12px;font-weight:600}
+.green{background:rgba(63,185,80,.15);color:var(--green)}
+.blue{background:rgba(31,111,235,.18);color:#79b8ff}
+.res{border-top:1px solid var(--line);padding:12px 0}
+.res:first-child{border-top:0}
+.res .t{font-weight:700}.res .m{color:var(--muted);font-size:13px}
+.kind{font-size:11px;text-transform:uppercase;letter-spacing:.04em;color:var(--gold)}
+.sc{float:right;color:var(--green);font-variant-numeric:tabular-nums}
+a{color:#79b8ff}
+.foot{color:var(--muted);font-size:12px;margin-top:24px;border-top:1px solid var(--line);padding-top:12px}
+code{color:var(--gold)}
+.stat{color:var(--muted);font-size:13px;margin-top:8px}
+.chips{margin-top:10px}.chip{display:inline-block;margin:2px 4px 2px 0;padding:4px 10px;border:1px solid var(--line);
+border-radius:999px;font-size:12px;color:var(--muted);cursor:pointer;background:#0d141c}
+.chip:hover{border-color:var(--gold);color:var(--gold)}
+</style></head>
+<body><div class="wrap">
+<h1>Sovereign Corpus Search <span class="pill green">0 CDN · 0 service</span></h1>
+<p class="sub">Sub-second BM25 relevance search over the entire a11oy governed-AI substrate —
+model catalog, decision receipts and doctrine — answered <b>locally</b>, with no Elasticsearch,
+no Meilisearch and no network egress. Pattern from <code>phiresky/tantivy-wasm</code> (MIT),
+evolved into a dependency-free server-side Okapi&nbsp;BM25 engine (the air-gap search story).</p>
+
+<div class="card">
+<div class="row">
+<input id="q" placeholder="search the governance corpus (e.g. air-gap classified, budget tier, khipu receipt)…" />
+<button id="go">Search</button>
+<button id="rx" style="background:#1f6feb;color:#fff">Reindex</button>
+</div>
+<div class="chips" id="chips">
+<span class="chip">air-gap classified</span>
+<span class="chip">budget tier mission</span>
+<span class="chip">khipu hash-chain receipt</span>
+<span class="chip">consensus cluster</span>
+<span class="chip">conjecture lambda</span>
+</div>
+<div class="stat" id="stat">Building index…</div>
+</div>
+
+<div class="card" id="resCard" style="display:none">
+<div id="res"></div>
+</div>
+
+<p class="foot">a11oy · Doctrine v11 LOCKED 749/14/163 · Λ = Conjecture 1 ·
+pattern: phiresky/tantivy-wasm (MIT), evolved · sovereign 0-CDN (no JS deps at all).</p>
+</div>
+<script>
+const $=s=>document.querySelector(s);
+async function stats(){
+  const s=await(await fetch('/api/a11oy/v1/search/corpus')).json();
+  const bk=Object.entries(s.by_kind||{}).map(([k,v])=>k+'='+v).join(', ');
+  $('#stat').textContent='index ready · '+s.doc_count+' docs ('+bk+') · '
+    +s.unique_terms+' unique terms · '+s.ranker;
+}
+async function run(q){
+  if(!q){return}
+  const d=await(await fetch('/api/a11oy/v1/search/query?q='+encodeURIComponent(q)+'&k=8')).json();
+  const box=$('#res'); box.innerHTML='';
+  $('#resCard').style.display='block';
+  if(!d.results.length){box.innerHTML='<div class="res m">No matches in the governed corpus for “'+q+'”.</div>';return}
+  for(const r of d.results){
+    const el=document.createElement('div');el.className='res';
+    el.innerHTML='<span class="sc">'+r.score.toFixed(3)+'</span>'
+      +'<div class="kind">'+r.kind+'</div>'
+      +'<div class="t">'+r.title+'</div>'
+      +'<div class="m">'+r.snippet+'</div>'
+      +'<div class="m">matched: '+r.matched_terms.join(', ')
+      +(r.ref?(' · <a href="'+r.ref+'">'+r.ref+'</a>'):'')+'</div>';
+    box.appendChild(el);
+  }
+}
+$('#go').addEventListener('click',()=>run($('#q').value));
+$('#q').addEventListener('keydown',e=>{if(e.key==='Enter')run($('#q').value)});
+$('#rx').addEventListener('click',async()=>{await fetch('/api/a11oy/v1/search/reindex');stats();});
+document.querySelectorAll('.chip').forEach(c=>c.addEventListener('click',()=>{
+  $('#q').value=c.textContent;run(c.textContent);}));
+stats();
+</script>
+</body></html>"""