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

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

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

static/3d/holographic.html

@@ -107,6 +107,10 @@ const SURFACES = [
   { id: "graphmem", title: "Multi-Graph Agentic Memory", mod: "/static/3d/surfaces/graphmem.js" },
   { id: "elf", title: "Continuous-Embedding Flow LM", mod: "/static/3d/surfaces/elf.js" },
   { id: "s3search", title: "Stratified Denoise Search", mod: "/static/3d/surfaces/s3search.js" },
+  { id: "slidesparse", title: "Structured-Sparse Layout Packing", mod: "/static/3d/surfaces/slidesparse.js" },
+  { id: "catq", title: "Calibration Ternary Quant", mod: "/static/3d/surfaces/catq.js" },
+  { id: "rauq", title: "Attention-Pattern Uncertainty", mod: "/static/3d/surfaces/rauq.js" },
+  { id: "agentcoh", title: "Multi-Agent Memory Coherence", mod: "/static/3d/surfaces/agentcoh.js" },
   { id: "energy",      title: "Energy",      mod: "/static/3d/surfaces/energy.js" },
   { id: "fabric",      title: "Fabric",      mod: "/static/3d/surfaces/fabric.js" },
   { id: "pnt",         title: "PNT",         mod: "/static/3d/surfaces/pnt.js" },

static/3d/surfaces/agentcoh.js

@@ -0,0 +1,457 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/agentcoh.js — MULTI-AGENT MEMORY COHERENCE organ (NEW AXIS) for the
+// holographic frontier ring, clean-room-inspired by (NOT a reproduction of) the
+// TOKEN COHERENCE idea (arXiv:2603.15183, Parakhin): naive multi-agent LLM
+// orchestration rebroadcasts full shared state on every update, costing O(n·S·|D|);
+// this maps onto SHARED-MEMORY CACHE COHERENCE — an artifact held by several agents
+// is a cache line held by several cores. This organ ports the MESI protocol
+// (Modified/Exclusive/Shared/Invalid + LAZY INVALIDATION) to artifacts.
+//
+// Visual: a grid of MESI state LANES — one row per (agent, artifact) cache entry —
+// advancing left-to-right along the operation trace. Each cell's colour encodes its
+// MESI state; invalidation events flash on the writer→peer links. A side panel shows
+// the naive-vs-MESI cost curve as write_fraction sweeps, and the three invariant
+// PASS/FAIL lights (mesi_buggy surfaces a stale-read FAIL). Honesty label "MODELED"
+// is read VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors episodic.js / graphmem.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   timeline[]            — per-artifact { artifact, lanes:[{agent, states:[...]}] }
+//   naive / mesi          — { coordinator, cost, invalidations, refetches, ... }
+//   invariants            — { single_writer, monotonic_versioning, bounded_staleness }
+//   cost_curve[]          — { write_fraction, naive_cost, mesi_cost, savings_ratio }
+//   invalidation_events[] — { step, artifact, from, to }
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Token Coherence (MESI→artifact protocol; Parakhin): https://arxiv.org/abs/2603.15183
+//   Multi-Agent Memory from a Computer Architecture Perspective (Yu et al.):
+//     https://arxiv.org/abs/2603.10062
+//   Governed Shared Memory for Multi-Agent LLM Systems: https://arxiv.org/abs/2606.24535
+//
+// HONESTY LABELS: MODELED (toy deterministic sim of the MESI→artifact coherence
+//   MECHANISM; integer-versioned dict entries; cost is a counted token/byte proxy, not
+//   measured LLM tokens; invariants via in-sim assertions, NOT a TLA+ checker; no
+//   LangGraph/CrewAI/AutoGen). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (Shared / Exclusive lanes + naive cost), violet-blue
+//   0x8a6bff (Modified writer lane + invalidation flash — data-viz only), proof-teal
+//   0x3af4c8 (MESI cost / invariant-PASS accent), greys for Invalid / degraded / no-data.
+//   Purple BANNED as UI/background.
+// 0 RUNTIME CDN. three.js via ctx.THREE (vendored r170 through the page importmap).
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+
+const ID    = "agentcoh";
+const TITLE = "Multi-Agent Memory Coherence · MESI→artifact (live)";
+
+// Endpoint on the dedicated killinchu Space (isolated compute), reached cross-origin.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/agentcoh/sync?seed=42&num_agents=3&num_artifacts=4&write_fraction=0.35&mode=mesi";
+
+// data-viz hues — purple BANNED
+const C_SHARED = 0x5b8dee;  // lattice-blue (Shared / Exclusive lane + naive cost bar)
+const C_MOD    = 0x8a6bff;  // violet-blue (Modified writer lane + invalidation flash — data-viz only)
+const C_ACCENT = 0x3af4c8;  // proof-teal (MESI cost bar / invariant-PASS accent)
+const C_DIM    = 0x42505d;  // grey (Invalid lane / degraded / no-live-data)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+const N_ART   = 4;    // artifact rows (matches endpoint default cap of visualization)
+const N_AGENT = 3;    // agent sub-lanes per artifact
+const N_STEP  = 24;   // visible trace steps (columns) along the x-axis
+const SPAN_X  = 18;   // world-unit span of the trace axis
+const LANE_DY = 0.9;  // vertical spacing between agent lanes
+const ART_DY  = 3.4;  // vertical spacing between artifact blocks
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _cells = [];        // Array<THREE.Mesh> — one cell per (artifact, agent, step)
+let _links = null;      // THREE.LineSegments — invalidation event links
+let _flash = [];        // per-cell flash timer (invalidation highlight)
+
+// live state
+const S = {
+  label:       null,
+  timeline:    null,   // Array<{artifact, lanes:[{agent, states:[...]}]}>
+  naive:       null,   // {coordinator, cost, ...}
+  mesi:        null,   // {coordinator, cost, invalidations, refetches, ...}
+  invariants:  null,   // {single_writer, monotonic_versioning, bounded_staleness, all_hold}
+  costCurve:   null,   // Array<{write_fraction, naive_cost, mesi_cost, savings_ratio}>
+  invEvents:   null,   // Array<{step, artifact, from, to}>
+  mode:        null,
+  state:       "init",
+};
+
+// map a MESI state string to a data-viz colour
+function _stateColor(st, live) {
+  if (!live) return C_DIM;
+  if (st === "Modified")  return C_MOD;
+  if (st === "Exclusive") return C_SHARED;
+  if (st === "Shared")    return C_SHARED;
+  if (st === "Invalid")   return C_DIM;
+  return C_DIM;
+}
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(0, 9, 26);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 3, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildCells();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onSync, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); _paintCells(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(44, 44, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.16; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+}
+
+function _buildCells() {
+  const THREE = _THREE;
+  const geo = new THREE.BoxGeometry(0.5, 0.28, 0.5);
+  _cells = [];
+  _flash = [];
+  // rows: artifact block (N_ART), each with N_AGENT lanes; columns: N_STEP trace steps
+  for (let art = 0; art < N_ART; art++) {
+    for (let ag = 0; ag < N_AGENT; ag++) {
+      for (let st = 0; st < N_STEP; st++) {
+        const mat = new THREE.MeshStandardMaterial({
+          color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.12,
+          metalness: 0.2, roughness: 0.6,
+        });
+        const mesh = new THREE.Mesh(geo, mat);
+        const x = (st / (N_STEP - 1)) * SPAN_X - SPAN_X / 2;
+        const y = art * ART_DY + ag * LANE_DY + 0.6;
+        mesh.position.set(x, y, 0);
+        mesh.userData = { art, ag, st };
+        _group.add(mesh);
+        _cells.push(mesh);
+        _flash.push(0);
+      }
+    }
+  }
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onSync(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label      = (j.label || "MODELED").toUpperCase();
+  S.timeline   = Array.isArray(j.timeline) ? j.timeline : null;
+  S.naive      = j.naive || null;
+  S.mesi       = j.mesi || null;
+  S.invariants = j.invariants || null;
+  S.costCurve  = Array.isArray(j.cost_curve) ? j.cost_curve : null;
+  S.invEvents  = Array.isArray(j.invalidation_events) ? j.invalidation_events : null;
+  S.mode       = j.mode || null;
+
+  _paintCells();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — colours each cell by its MESI state at that trace step
+// =============================================================================
+function _cellIndex(art, ag, st) {
+  return (art * N_AGENT + ag) * N_STEP + st;
+}
+
+function _paintCells() {
+  const live = S.state === "live";
+  const tl = S.timeline || [];
+
+  // default: dim everything
+  _cells.forEach((mesh) => {
+    mesh.material.color.setHex(C_DIM);
+    mesh.material.emissive.setHex(C_DIM);
+    mesh.material.emissiveIntensity = 0.1;
+    mesh.scale.set(1, 1, 1);
+  });
+
+  if (tl.length) {
+    for (let art = 0; art < Math.min(N_ART, tl.length); art++) {
+      const lanes = (tl[art] && tl[art].lanes) || [];
+      for (let ag = 0; ag < Math.min(N_AGENT, lanes.length); ag++) {
+        const states = (lanes[ag] && lanes[ag].states) || [];
+        for (let st = 0; st < N_STEP; st++) {
+          const stName = states[st];
+          if (stName === undefined) continue;
+          const mesh = _cells[_cellIndex(art, ag, st)];
+          if (!mesh) continue;
+          const col = _stateColor(stName, live);
+          mesh.material.color.setHex(col);
+          mesh.material.emissive.setHex(col);
+          const isMod = live && stName === "Modified";
+          const isInv = stName === "Invalid";
+          mesh.material.emissiveIntensity = live ? (isMod ? 0.85 : (isInv ? 0.08 : 0.35)) : 0.1;
+          mesh.scale.set(1, isMod ? 2.0 : (isInv ? 0.5 : 1.0), 1);
+        }
+      }
+    }
+  }
+
+  // rebuild invalidation-event links (writer step -> flash on the invalidated lanes)
+  if (_links) { _group.remove(_links); _links.geometry.dispose(); _links.material.dispose(); _links = null; }
+  const evs = S.invEvents || [];
+  if (live && evs.length) {
+    const THREE = _THREE;
+    const pts = [];
+    evs.forEach((e) => {
+      if (e.step >= N_STEP || e.artifact >= N_ART) return;
+      if (e.from >= N_AGENT || e.to >= N_AGENT) return;
+      const a = _cells[_cellIndex(e.artifact, e.from, e.step)];
+      const b = _cells[_cellIndex(e.artifact, e.to, e.step)];
+      if (!a || !b) return;
+      pts.push(a.position.clone(), b.position.clone());
+      const bi = _cellIndex(e.artifact, e.to, e.step);
+      _flash[bi] = 60;
+    });
+    if (pts.length) {
+      const g = new THREE.BufferGeometry().setFromPoints(pts);
+      _links = new THREE.LineSegments(g, new THREE.LineBasicMaterial({ color: C_MOD, transparent: true, opacity: 0.4 }));
+      _group.add(_links);
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.0001) * 0.12;
+  const live = S.state === "live";
+  for (let i = 0; i < _cells.length; i++) {
+    if (_flash[i] > 0) {
+      _flash[i] -= 1;
+      const f = _flash[i] / 60;
+      const col = live ? C_MOD : C_DIM;
+      _cells[i].material.emissive.setHex(col);
+      _cells[i].material.emissiveIntensity = Math.max(_cells[i].material.emissiveIntensity, 0.2 + 0.8 * f);
+    }
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,460px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A grid of <b>MESI state lanes</b> \u2014 one row per (agent, artifact) cache entry \u2014 ' +
+    'advancing along a fixed seeded op trace. Two coordinators run the SAME trace: ' +
+    '<b>naive broadcast</b> (re-sends the full artifact to all agents on every write) vs ' +
+    '<b>MESI-ACS</b> (lazy invalidation + on-demand re-fetch). Three invariants are ' +
+    'asserted; <b>mesi_buggy</b> drops an invalidation to expose a stale read. Honesty ' +
+    'label <b>MODELED</b> (Token-Coherence-inspired \u2014 not a reproduction). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "agentcoh";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:60%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("ac-mode",   "mode"));
+  grid.appendChild(kpiRow("ac-naive",  "naive-broadcast cost"));
+  grid.appendChild(kpiRow("ac-mesi",   "MESI-ACS cost"));
+  grid.appendChild(kpiRow("ac-save",   "cost saved (this trace)"));
+  grid.appendChild(kpiRow("ac-inv",    "invariants (SW / MV / BS)"));
+  grid.appendChild(kpiRow("ac-label",  "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Token Coherence arXiv:2603.15183 (Parakhin) \u00b7 Multi-Agent Memory / Comp-Arch arXiv:2603.10062 (Yu et al.) \u00b7 Governed Shared Memory arXiv:2606.24535. MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "ac-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const nc = (S.naive && typeof S.naive.cost === "number") ? String(S.naive.cost) : "loading\u2026";
+  const mc = (S.mesi && typeof S.mesi.cost === "number") ? String(S.mesi.cost) : "loading\u2026";
+  let save = "loading\u2026";
+  if (S.naive && S.mesi && S.naive.cost) {
+    save = (100 * (1 - S.mesi.cost / S.naive.cost)).toFixed(0) + "%";
+  }
+  const allHold = S.invariants ? (S.invariants.all_hold ? "all HOLD" : "one FAILS (see BS)") : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> When several AI agents share the same working memory, the " +
+    "naive fix is to re-send the entire shared state to everyone on every change \u2014 " +
+    "expensive and slow (here it costs <b>" + nc + "</b> proxy units on this trace). " +
+    "Borrowing a 40-year-old trick from computer CPUs (the <b>MESI cache-coherence " +
+    "protocol</b>), we instead send tiny \u201cyour copy is stale\u201d notices and only re-fetch " +
+    "the full data when an agent actually reads it \u2014 dropping the cost to <b>" + mc + "</b> " +
+    "(about <b>" + save + "</b> cheaper) while still guaranteeing only one agent writes at a " +
+    "time, versions never go backwards, and reads are never too stale (" + allHold + "). " +
+    "The <b>mesi_buggy</b> mode deliberately skips one \u201cstale\u201d notice so you can watch a " +
+    "guarantee break. " +
+    "<br><br><b>Honesty (MODELED):</b> Inspired-not-real. This is a toy deterministic " +
+    "simulation of the MESI\u2192artifact coherence MECHANISM, not the paper\u2019s Artifact " +
+    "Coherence System. \u201cArtifacts\u201d are integer-versioned dict entries over 3\u20134 items and " +
+    "a handful of agents; \u201ccost\u201d is a counted token/byte proxy, not measured LLM tokens; " +
+    "invariants are checked by in-sim assertions, NOT the paper\u2019s TLA+ model checker (no " +
+    "~2,400-state exploration); there is no LangGraph/CrewAI/AutoGen integration. It " +
+    "demonstrates WHY lazy invalidation beats full-state rebroadcast while preserving " +
+    "single-writer safety, monotonic versioning and bounded staleness on a constructed " +
+    "trace; it does NOT reproduce Token Coherence\u2019s 84\u201395% measured savings or prove the " +
+    "Token Coherence Theorem. <b>NEW AXIS:</b> this is a distributed-consistency protocol " +
+    "(\u2260 graphmem retrieval, \u2260 single-agent memory organs, \u2260 governance policy).";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _invLetter(x) {
+  if (!x || !x.status) return "\u2014";
+  return x.status === "PASS" ? "\u2713" : "\u2717";
+}
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("ac-mode",  t || (S.mode || "\u2014"));
+  _set("ac-naive", t || (S.naive && typeof S.naive.cost === "number" ? String(S.naive.cost) : "\u2014"));
+  _set("ac-mesi",  t || (S.mesi && typeof S.mesi.cost === "number" ? String(S.mesi.cost) : "\u2014"));
+  let save = "\u2014";
+  if (S.naive && S.mesi && S.naive.cost) {
+    save = (100 * (1 - S.mesi.cost / S.naive.cost)).toFixed(1) + "%";
+  }
+  _set("ac-save",  t || save);
+  let inv = "\u2014";
+  if (S.invariants) {
+    inv = _invLetter(S.invariants.single_writer) + " " +
+          _invLetter(S.invariants.monotonic_versioning) + " " +
+          _invLetter(S.invariants.bounded_staleness);
+  }
+  _set("ac-inv",   t || inv);
+  // honesty label verbatim — never upgraded
+  _set("ac-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _cells = []; _flash = []; _links = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.timeline = S.naive = S.mesi = S.invariants = null;
+  S.costCurve = S.invEvents = S.mode = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/catq.js

@@ -0,0 +1,514 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/catq.js — POST-TRAINING CALIBRATION TERNARY QUANT (CAT-Q) organ for
+// the holographic frontier ring. A SUB-ORGAN UPGRADE of the `ternary` organ:
+// same weight-precision axis {-1,0,+1}, distinct PTQ-vs-QAT mechanism. Renders
+// a 3D weight-magnitude histogram of a frozen synthetic heavy-tailed weight
+// vector, with the ABSMEAN hard-snap threshold and the CAT-Q LEARNED threshold
+// drawn as gates; bars are coloured by the ternary code each rule assigns
+// (+1 -> add proof-teal, -1 -> subtract lattice-blue, 0 -> skip grey). A HUD
+// shows the MEASURED reconstruction / calibration-task error, absmean vs CAT-Q,
+// from the live snapshot at /api/killinchu/v1/catq/calibrate. Honesty label
+// "MODELED" is read VERBATIM from the JSON and displayed as-is; never upgraded.
+//
+// Surface export shape (mirrors ternary.js / aimc.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   num_weights, num_calibration_samples, modulation_groups, softening_steps,
+//   absmean_threshold, catq_threshold_frac, ternary_counts_absmean{neg,zero,pos},
+//   ternary_counts_catq{neg,zero,pos}, recon_err_absmean, recon_err_catq,
+//   recon_err_improvement_frac, calib_task_err_absmean, calib_task_err_catq,
+//   error_vs_calibration[{n,task_err}], bits_per_weight_ternary
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFIED real):
+//   CAT-Q: Cost-efficient and Accurate Ternary Quantization for LLMs
+//     Wang, Li, Kang, Fan, Yao (2026). arXiv:2606.26650
+//     https://arxiv.org/abs/2606.26650
+//
+// HONESTY LABEL: MODELED — toy analytic sim of the post-training calibration-
+//   ternarization MECHANISM, not CAT-Q. Seeded synthetic heavy-tailed weights,
+//   seeded toy activations, a tiny closed-form/least-squares "learnable
+//   modulation" + fixed tanh-anneal "softened ternarization"; NO real LLM, NO
+//   BitTern code, NO 512-sample calibration of a 1.7B–235B model, NO GPU-hours.
+//   Explicitly a SUB-ORGAN UPGRADE of ternary (same weight-precision axis,
+//   distinct PTQ-vs-QAT mechanism), not a new axis. Read verbatim from JSON.
+// COLOURS: proof-teal 0x3af4c8 (+1 -> add), lattice-blue 0x5b8dee (-1 ->
+//   subtract), violet-blue 0x8a6bff (learned-threshold / calibration accent),
+//   greys (0 -> skip / degraded). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js via ctx.THREE (page importmap).
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "catq";
+const TITLE = "Post-Training Calibration Ternary Quant · CAT-Q (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/catq/calibrate?seed=42&num_weights=256&num_calibration_samples=512&mode=catq";
+
+// data-viz hues — purple BANNED
+const C_POS      = 0x3af4c8;  // proof-teal (+1 weight -> add)
+const C_NEG      = 0x5b8dee;  // lattice-blue (-1 weight -> subtract)
+const C_LEARNED  = 0x8a6bff;  // violet-blue (learned-threshold / calibration accent)
+const C_ZERO     = 0x5a6570;  // grey (0 weight -> skip / structured sparsity)
+const C_DIM      = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID     = 0x1b3a44;  // floor / link colour
+
+// histogram layout geometry
+const N_BINS     = 24;     // magnitude bins per side of the histogram
+const BIN_GAP    = 0.42;   // world-units between bins
+const MAX_H      = 4.0;    // max bar height (world units)
+const ROW_ABS    = 0.0;    // z-row for the ABSMEAN (before) histogram
+const ROW_CATQ   = 3.2;    // z-row for the CAT-Q (after) histogram
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _floor     = null;
+let _barsAbs   = [];   // Array<THREE.Mesh> — absmean (before) histogram bars
+let _barsCatq  = [];   // Array<THREE.Mesh> — CAT-Q (after) histogram bars
+let _gateAbs   = null; // THREE.Mesh — absmean hard threshold gate
+let _gateCatq  = null; // THREE.Mesh — CAT-Q learned threshold gate
+
+// live state
+const S = {
+  label:            null,
+  numWeights:       null,
+  numCalib:         null,
+  modGroups:        null,
+  softSteps:        null,
+  absmeanThresh:    null,   // absmean_threshold
+  catqThreshFrac:   null,   // catq_threshold_frac
+  absNeg:           null, absZero: null, absPos: null,   // ternary_counts_absmean
+  catqNeg:          null, catqZero: null, catqPos: null, // ternary_counts_catq
+  reconErrAbs:      null,   // recon_err_absmean (MEASURED)
+  reconErrCatq:     null,   // recon_err_catq (MEASURED)
+  reconImprovFrac:  null,   // recon_err_improvement_frac
+  taskErrAbs:       null,   // calib_task_err_absmean (MEASURED)
+  taskErrCatq:      null,   // calib_task_err_catq (MEASURED)
+  bitsPerWeight:    null,   // bits_per_weight_ternary
+  curve:            null,   // error_vs_calibration [{n, task_err}]
+  state:            "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(6, 8, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(5, 1, 1.5); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildHistograms();
+  _buildGates();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onCatq, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Two rows of magnitude-histogram bars: the "before" (absmean hard-snap) row and
+// the "after" (CAT-Q learned-threshold + calibrated modulation) row. We toggle
+// height / colour in-place as live data arrives (no per-poll geometry churn).
+function _buildHistograms() {
+  const THREE = _THREE;
+  const barGeo = new THREE.BoxGeometry(0.28, 1.0, 0.28);
+  for (let b = 0; b < N_BINS; b++) {
+    const mAbs = new THREE.Mesh(
+      barGeo,
+      new THREE.MeshStandardMaterial({ color: C_ZERO, emissive: C_ZERO, emissiveIntensity: 0.2, transparent: true, opacity: 0.0 }),
+    );
+    mAbs.position.set(b * BIN_GAP, 0.5, ROW_ABS);
+    mAbs.visible = false;
+    _group.add(mAbs);
+    _barsAbs.push(mAbs);
+
+    const mCatq = new THREE.Mesh(
+      barGeo,
+      new THREE.MeshStandardMaterial({ color: C_ZERO, emissive: C_ZERO, emissiveIntensity: 0.2, transparent: true, opacity: 0.0 }),
+    );
+    mCatq.position.set(b * BIN_GAP, 0.5, ROW_CATQ);
+    mCatq.visible = false;
+    _group.add(mCatq);
+    _barsCatq.push(mCatq);
+  }
+}
+
+// Threshold "gates": thin planes marking the absmean hard threshold (before row)
+// and the CAT-Q learned threshold (after row). Bins to the left of the gate
+// ternarize to 0 (skip); bins to the right ternarize to ±1.
+function _buildGates() {
+  const THREE = _THREE;
+  const gateGeo = new THREE.BoxGeometry(0.06, MAX_H, 0.9);
+  _gateAbs = new THREE.Mesh(
+    gateGeo,
+    new THREE.MeshStandardMaterial({ color: C_ZERO, emissive: C_ZERO, emissiveIntensity: 0.4, transparent: true, opacity: 0.0 }),
+  );
+  _gateAbs.position.set(0, MAX_H / 2, ROW_ABS);
+  _gateAbs.visible = false;
+  _group.add(_gateAbs);
+
+  _gateCatq = new THREE.Mesh(
+    gateGeo,
+    new THREE.MeshStandardMaterial({ color: C_LEARNED, emissive: C_LEARNED, emissiveIntensity: 0.55, transparent: true, opacity: 0.0 }),
+  );
+  _gateCatq.position.set(0, MAX_H / 2, ROW_CATQ);
+  _gateCatq.visible = false;
+  _group.add(_gateCatq);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onCatq(j) {
+  // read honesty label VERBATIM — never upgrade. handle top-level 'label' OR
+  // nested 'payload.label' to match our own module's shape.
+  const lbl = (j && j.label != null) ? j.label
+            : (j && j.payload && j.payload.label != null) ? j.payload.label
+            : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : j;
+  S.label           = String(lbl).toUpperCase();
+
+  S.numWeights      = typeof src.num_weights                === "number" ? src.num_weights                : null;
+  S.numCalib        = typeof src.num_calibration_samples    === "number" ? src.num_calibration_samples    : null;
+  S.modGroups       = typeof src.modulation_groups          === "number" ? src.modulation_groups          : null;
+  S.softSteps       = typeof src.softening_steps            === "number" ? src.softening_steps            : null;
+  S.absmeanThresh   = typeof src.absmean_threshold          === "number" ? src.absmean_threshold          : null;
+  S.catqThreshFrac  = typeof src.catq_threshold_frac        === "number" ? src.catq_threshold_frac        : null;
+  S.reconErrAbs     = typeof src.recon_err_absmean          === "number" ? src.recon_err_absmean          : null;
+  S.reconErrCatq    = typeof src.recon_err_catq             === "number" ? src.recon_err_catq             : null;
+  S.reconImprovFrac = typeof src.recon_err_improvement_frac === "number" ? src.recon_err_improvement_frac : null;
+  S.taskErrAbs      = typeof src.calib_task_err_absmean     === "number" ? src.calib_task_err_absmean     : null;
+  S.taskErrCatq     = typeof src.calib_task_err_catq        === "number" ? src.calib_task_err_catq        : null;
+  S.bitsPerWeight   = typeof src.bits_per_weight_ternary    === "number" ? src.bits_per_weight_ternary    : null;
+  S.curve           = Array.isArray(src.error_vs_calibration) ? src.error_vs_calibration : null;
+
+  if (src.ternary_counts_absmean && typeof src.ternary_counts_absmean === "object") {
+    S.absNeg  = typeof src.ternary_counts_absmean.neg  === "number" ? src.ternary_counts_absmean.neg  : null;
+    S.absZero = typeof src.ternary_counts_absmean.zero === "number" ? src.ternary_counts_absmean.zero : null;
+    S.absPos  = typeof src.ternary_counts_absmean.pos  === "number" ? src.ternary_counts_absmean.pos  : null;
+  }
+  if (src.ternary_counts_catq && typeof src.ternary_counts_catq === "object") {
+    S.catqNeg  = typeof src.ternary_counts_catq.neg  === "number" ? src.ternary_counts_catq.neg  : null;
+    S.catqZero = typeof src.ternary_counts_catq.zero === "number" ? src.ternary_counts_catq.zero : null;
+    S.catqPos  = typeof src.ternary_counts_catq.pos  === "number" ? src.ternary_counts_catq.pos  : null;
+  }
+
+  _updateHistograms();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — draws the before/after magnitude histograms + gates
+// =============================================================================
+// Deterministic per-bin heavy-tailed magnitude profile (LCG family, mirrors the
+// module) so the histogram shape is stable across polls and never fabricated
+// beyond a heavy-tailed envelope: most mass near zero, a light tail out to the
+// right (the pretrained-weight outliers). This is a VISUAL proxy for the
+// reported distribution — the numeric metrics come only from the live JSON.
+function _binMass(b) {
+  // heavy-tailed-ish falloff with a small deterministic ripple
+  let s = ((b + 1) * 2654435761) >>> 0;
+  s = (1664525 * s + 1013904223) >>> 0;
+  const ripple = 0.12 * ((s / 4294967295) - 0.5);
+  const x = b / (N_BINS - 1);
+  const env = Math.exp(-3.1 * x) + 0.05 * Math.exp(-0.6 * (1.0 - x)); // bulk + tail
+  return Math.max(0.02, env + ripple);
+}
+
+function _updateHistograms() {
+  const live = S.state === "live";
+
+  // gate bin positions from live thresholds (normalized to the bin axis).
+  // absmean threshold in weight-units -> map through a nominal magnitude span;
+  // CAT-Q learned threshold = catq_threshold_frac * (absmean_threshold/0.5)
+  // since absmean_threshold = 0.5*beta => beta = absmean_threshold/0.5.
+  const beta = (S.absmeanThresh != null) ? (S.absmeanThresh / 0.5) : 1.0;
+  const span = Math.max(1e-6, 3.0 * beta);                 // nominal |w| axis span
+  const absBin  = live && S.absmeanThresh  != null ? Math.min(N_BINS - 1, (S.absmeanThresh / span) * N_BINS) : 0;
+  const catqThr = (S.catqThreshFrac != null) ? S.catqThreshFrac * beta : null;
+  const catqBin = live && catqThr != null ? Math.min(N_BINS - 1, (catqThr / span) * N_BINS) : 0;
+
+  for (let b = 0; b < N_BINS; b++) {
+    const mass = _binMass(b);
+    const h = MAX_H * mass;
+
+    _updateBar(_barsAbs[b],  b, h, live, absBin,  false);
+    _updateBar(_barsCatq[b], b, h, live, catqBin, true);
+  }
+
+  _placeGate(_gateAbs,  absBin,  ROW_ABS,  C_ZERO,    live);
+  _placeGate(_gateCatq, catqBin, ROW_CATQ, C_LEARNED, live);
+}
+
+function _updateBar(mesh, b, h, live, gateBin, isCatq) {
+  if (!mesh) return;
+  if (!live) { mesh.visible = false; return; }
+  mesh.visible = true;
+  mesh.scale.y = Math.max(0.04, h);
+  mesh.position.y = mesh.scale.y * 0.5;
+  // bins beyond the (soft/hard) threshold ternarize to ±1; below -> 0 (skip).
+  let color;
+  if (b < gateBin) {
+    color = C_ZERO;                              // 0 -> skip (grey)
+  } else {
+    color = (b % 2 === 0) ? C_POS : C_NEG;       // ±1 -> add / subtract
+  }
+  mesh.material.color.setHex(color);
+  mesh.material.emissive.setHex(color);
+  mesh.material.emissiveIntensity = (b < gateBin) ? 0.14 : (isCatq ? 0.6 : 0.42);
+  mesh.material.opacity = (b < gateBin) ? 0.32 : 0.95;
+}
+
+function _placeGate(gate, bin, row, litColor, live) {
+  if (!gate) return;
+  if (!live) { gate.visible = false; return; }
+  gate.visible = true;
+  gate.position.set(bin * BIN_GAP - BIN_GAP * 0.5, MAX_H / 2, row);
+  gate.material.color.setHex(litColor);
+  gate.material.emissive.setHex(litColor);
+  gate.material.opacity = 0.5;
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00009) * 0.12;
+  if (_gateCatq && _gateCatq.visible) {
+    const pulse = 0.5 + 0.18 * Math.sin(t * 0.004);
+    _gateCatq.material.opacity = pulse;
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,470px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A <b>SUB-ORGAN UPGRADE of ternary</b> (same weight-precision axis {\u22121,0,+1}, distinct PTQ-vs-QAT ' +
+    'mechanism). Instead of training a ternary model from scratch, <b>CAT-Q</b> ternarizes an already-' +
+    'pretrained model <b>post-training</b> from a small calibration set. Two components: <b>learnable ' +
+    'modulation</b> (a closed-form least-squares fit reshapes the per-group scale + threshold) and ' +
+    '<b>softened ternarization</b> (a tanh-anneal transition instead of a hard snap). The two histograms ' +
+    'show the same frozen weights ternarized by the <b>absmean hard threshold</b> (before) vs the ' +
+    '<b>CAT-Q learned threshold</b> (after). HUD reports MEASURED reconstruction / calibration-task error, ' +
+    'absmean vs CAT-Q. Honesty label <b>MODELED</b>. 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#3af4c8;box-shadow:0 0 7px #3af4c8";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#3af4c8;letter-spacing:.3px";
+  nm.textContent = "post-training calibration ternary quant (cat-q)";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:56%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("cq-weights",   "frozen weights (heavy-tailed)"));
+  grid.appendChild(kpiRow("cq-calib",     "calibration samples"));
+  grid.appendChild(kpiRow("cq-groups",    "modulation groups (LM)"));
+  grid.appendChild(kpiRow("cq-steps",     "softening steps (ST, tanh-anneal)"));
+  grid.appendChild(kpiRow("cq-absthr",    "absmean hard threshold"));
+  grid.appendChild(kpiRow("cq-catqthr",   "CAT-Q learned threshold frac"));
+  grid.appendChild(kpiRow("cq-absmix",    "absmean mix (\u22121 / 0 / +1)"));
+  grid.appendChild(kpiRow("cq-catqmix",   "CAT-Q mix (\u22121 / 0 / +1)"));
+  grid.appendChild(kpiRow("cq-reconabs",  "recon err \u2014 absmean (MEASURED)"));
+  grid.appendChild(kpiRow("cq-reconcatq", "recon err \u2014 CAT-Q (MEASURED)"));
+  grid.appendChild(kpiRow("cq-reconimp",  "recon err REDUCED by CAT-Q"));
+  grid.appendChild(kpiRow("cq-taskabs",   "calib-task err \u2014 absmean"));
+  grid.appendChild(kpiRow("cq-taskcatq",  "calib-task err \u2014 CAT-Q"));
+  grid.appendChild(kpiRow("cq-curve",     "task err vs calib (first \u2192 last)"));
+  grid.appendChild(kpiRow("cq-bpw",       "bits/weight (ternary) \u2014 MODELED"));
+  grid.appendChild(kpiRow("cq-label",     "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "CAT-Q \u2014 Wang, Li, Kang, Fan, Yao (2026) arXiv:2606.26650. SUB-ORGAN UPGRADE of ternary (same weight-precision axis, distinct PTQ-vs-QAT mechanism). MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "cq-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const impPct = S.reconImprovFrac != null ? (S.reconImprovFrac * 100).toFixed(1) + "%" : "loading\u2026";
+  const abs    = S.reconErrAbs     != null ? (S.reconErrAbs * 100).toFixed(1) + "%"    : "loading\u2026";
+  const cq     = S.reconErrCatq    != null ? (S.reconErrCatq * 100).toFixed(1) + "%"   : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Squeezing a language model down to three-value (\u201cternary\u201d) weights " +
+    "\u2014 minus one, zero, plus one \u2014 normally means re-training it from scratch on ~100 billion words, " +
+    "which is hugely expensive. <b>CAT-Q</b> instead takes a model that is <b>already trained</b>, freezes " +
+    "it, and calibrates the ternary conversion using only a tiny sample set \u2014 no re-training. It does this " +
+    "two ways: it <b>learns a better cut-off</b> (which weights become zero) and gently <b>eases</b> weights " +
+    "toward their ternary value instead of snapping them hard. Here, on a toy frozen weight set, that lowers " +
+    "the conversion error from about <b>" + abs + "</b> (plain absmean snap) to about <b>" + cq + "</b> \u2014 an " +
+    "improvement of roughly <b>" + impPct + "</b>, with <b>no re-training</b>. This is a <b>SUB-ORGAN UPGRADE " +
+    "of the ternary organ</b>: the same three-value weight idea, but a post-training-calibration mechanism " +
+    "instead of train-from-scratch. It is <b>MODELED</b> \u2014 a deterministic toy simulation of the mechanism, " +
+    "NOT a real large model, NOT the CAT-Q authors' code, and it does NOT reproduce their published results " +
+    "versus BitNet or their ~100,000\u00d7 training-data reduction.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function pct(v, d) { return typeof v === "number" ? (v * 100).toFixed(d) + "%" : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("cq-weights",   t || (S.numWeights != null ? String(S.numWeights) : "\u2014"));
+  _set("cq-calib",     t || (S.numCalib != null ? String(S.numCalib) : "\u2014"));
+  _set("cq-groups",    t || (S.modGroups != null ? String(S.modGroups) : "\u2014"));
+  _set("cq-steps",     t || (S.softSteps != null ? String(S.softSteps) : "\u2014"));
+  _set("cq-absthr",    t || fx(S.absmeanThresh, 4));
+  _set("cq-catqthr",   t || fx(S.catqThreshFrac, 3));
+  _set("cq-absmix",    t || ((S.absNeg != null) ? (S.absNeg + " / " + S.absZero + " / " + S.absPos) : "\u2014"));
+  _set("cq-catqmix",   t || ((S.catqNeg != null) ? (S.catqNeg + " / " + S.catqZero + " / " + S.catqPos) : "\u2014"));
+  _set("cq-reconabs",  t || pct(S.reconErrAbs, 2));
+  _set("cq-reconcatq", t || pct(S.reconErrCatq, 2));
+  _set("cq-reconimp",  t || pct(S.reconImprovFrac, 2));
+  _set("cq-taskabs",   t || pct(S.taskErrAbs, 2));
+  _set("cq-taskcatq",  t || pct(S.taskErrCatq, 2));
+  let curveTxt = "\u2014";
+  if (S.curve && S.curve.length >= 2) {
+    const f = S.curve[0], l = S.curve[S.curve.length - 1];
+    if (typeof f.task_err === "number" && typeof l.task_err === "number") {
+      curveTxt = f.task_err.toFixed(2) + " \u2192 " + l.task_err.toFixed(2);
+    }
+  }
+  _set("cq-curve",     t || curveTxt);
+  _set("cq-bpw",       t || fx(S.bitsPerWeight, 4));
+  // honesty label verbatim — never upgraded
+  _set("cq-label",     t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _floor = null; _barsAbs = []; _barsCatq = []; _gateAbs = null; _gateCatq = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.numWeights = S.numCalib = S.modGroups = S.softSteps = null;
+  S.absmeanThresh = S.catqThreshFrac = null;
+  S.absNeg = S.absZero = S.absPos = null;
+  S.catqNeg = S.catqZero = S.catqPos = null;
+  S.reconErrAbs = S.reconErrCatq = S.reconImprovFrac = null;
+  S.taskErrAbs = S.taskErrCatq = S.bitsPerWeight = S.curve = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/rauq.js

@@ -0,0 +1,501 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/rauq.js — ATTENTION-PATTERN (recurrent attention-based) UNCERTAINTY organ for
+// the holographic frontier ring. SUB-ORGAN UPGRADE of sement.
+//
+// Same uncertainty axis as sement (hallucination / abstain-vs-answer), DISTINCT mechanism:
+// sement's true signal is MULTI-SAMPLE semantic entropy (resample K generations, cluster
+// meanings); RAUQ here reads INTRINSIC ATTENTION PATTERNS in a SINGLE forward pass — no
+// resampling. It identifies "uncertainty-aware" attention heads whose attention TO PRECEDING
+// TOKENS systematically DROPS during incorrect generations, auto-selects them, recurrently
+// aggregates their preceding-token attention with per-token confidence into one SEQUENCE-LEVEL
+// uncertainty scalar, and thresholds it to flag likely-wrong generations.
+//
+// Driven by a live snapshot from /api/killinchu/v1/rauq/score. The organ renders, per
+// selected head, an ATTENTION-MASS TIMELINE across the sequence: a lattice-blue polyline for a
+// CORRECT example (preceding-token mass stays HIGH) and a violet-blue polyline for an INCORRECT
+// example (preceding-token mass DROPS / falls on flagged spans). Two KPI columns compare the
+// RAUQ attention-drop score against a cheap OUTPUT-ENTROPY baseline (AUROC / accuracy / F1) —
+// the attention-drop signal separates the labeled toy set better. Honesty label "MODELED" is
+// read VERBATIM from the JSON and displayed as-is; never upgraded.
+//
+// IMPORTANT — MODELED, NOT A REAL TRANSFORMER:
+//   This organ simulates the attention-pattern-uncertainty MECHANISM on synthetic toy data.
+//   The "attention matrices" are SEEDED SYNTHETIC row-stochastic toys with correct/incorrect
+//   regimes BUILT IN BY CONSTRUCTION; there is NO real transformer, NO forward pass, and NO
+//   4-LLM / 12-task evaluation. "Head selection" separates a hand-made labeled toy set. It
+//   demonstrates WHY a drop in preceding-token attention mass in selected heads can serve as a
+//   single-pass uncertainty signal a naive output-entropy baseline misses on constructed cases;
+//   it does NOT reproduce RAUQ's QA/summarization/translation results or its <1% real-latency
+//   claim. Explicitly a SUB-ORGAN UPGRADE of sement (same uncertainty axis, distinct single-
+//   pass-attention vs multi-sample-semantic-entropy mechanism — the true sement signal is
+//   MULTI-SAMPLE), not a new axis. Stated plainly in "what this means" and echoed in the
+//   endpoint's own JSON payload (honest_note).
+//
+// Surface export shape (mirrors sement.js / interpretability.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// LEADER ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Vazhentsev, Rvanova, Kuzmin, Fadeeva, Lazichny, Panchenko, Panov, Baldwin, Sachan, Nakov &
+//     Shelmanov (2025) "Uncertainty-Aware Attention Heads: Efficient Unsupervised Uncertainty
+//     Quantification for LLMs" [RAUQ]. arXiv:2505.20045. https://arxiv.org/abs/2505.20045
+//
+// HONESTY LABEL: MODELED (simulation of the METHOD on synthetic toy data; seeded synthetic
+//   attention matrices, regimes built in by construction, NO real transformer). Read verbatim.
+// COLOURS: lattice-blue 0x5b8dee (correct-regime timeline / RAUQ column), violet-blue 0x8a6bff
+//   (incorrect-regime timeline — data-viz only), proof-teal 0x3af4c8 (selected-head accent /
+//   verdict), greys for dim/idle. Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js via page importmap (ctx.THREE).
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// This organ adds NOTHING to SZL's own locked-8 / Λ-Conjecture-1.
+
+const ID    = "rauq";
+const TITLE = "Attention-Pattern (Recurrent Attention) Uncertainty · sub-organ of sement (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship origin).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/rauq/score?seed=42&seq_len=8&num_heads=6&num_selected_heads=2&preceding_window=1&confidence_weight=0.4&threshold=0.5";
+
+// data-viz hues — purple BANNED
+const C_CORRECT = 0x5b8dee;  // lattice-blue (correct-regime timeline / RAUQ column)
+const C_WRONG   = 0x8a6bff;  // violet-blue (incorrect-regime timeline — data-viz only)
+const C_ACCENT  = 0x3af4c8;  // proof-teal accent (selected-head rails + verdict ring)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data / idle)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _lines = [];        // Array<THREE.Line>   — timeline polylines (per selected head x regime)
+let _nodes = [];        // Array<THREE.Mesh>   — per-position marker spheres
+let _rails = [];        // Array<THREE.Mesh>   — one rail bar per selected head
+let _ring  = null;      // verdict ring (rauq_beats_baseline)
+let _built = false;
+const _MAX_NODES = 256;
+const _pulse = new Float32Array(_MAX_NODES);
+
+// live state
+const S = {
+  label:       null,
+  seqLen:      null,
+  selectedHeads: [],   // Array<int>
+  threshold:   null,
+  beats:       null,   // rauq_beats_baseline
+  // one representative correct + one incorrect example, per selected head timeline
+  headTimelines: {},   // { headId: { correct: [..], incorrect: [..] } }
+  rauq:     { auroc: null, accuracy: null, precision: null, recall: null, f1: null },
+  baseline: { auroc: null, accuracy: null, precision: null, recall: null, f1: null },
+  state:    "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(0, 7, 22);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 2.2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildVerdict();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onScore, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); _updateGeometry(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(44, 44, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+}
+
+function _buildVerdict() {
+  const THREE = _THREE;
+  _ring = new THREE.Mesh(
+    new THREE.TorusGeometry(1.5, 0.05, 10, 48),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.4, transparent: true, opacity: 0.5 }),
+  );
+  _ring.position.set(0, 7.6, 0);
+  _ring.rotation.x = Math.PI / 2;
+  _group.add(_ring);
+}
+
+// Dispose only the timeline geometry (rebuilt whenever selected heads / data change).
+function _clearTimelines() {
+  const drop = (o) => {
+    try {
+      if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+      if (o.material) {
+        const ms = Array.isArray(o.material) ? o.material : [o.material];
+        ms.forEach((m) => { if (m.dispose) m.dispose(); });
+      }
+      if (_group) _group.remove(o);
+    } catch (_) {}
+  };
+  _lines.forEach(drop); _nodes.forEach(drop); _rails.forEach(drop);
+  _lines = []; _nodes = []; _rails = [];
+  _pulse.fill(0);
+}
+
+// Build one attention-mass timeline per selected head: a CORRECT polyline (lattice-blue,
+// preceding-mass stays high) and an INCORRECT polyline (violet-blue, preceding-mass drops).
+function _buildTimelines() {
+  const THREE = _THREE;
+  _clearTimelines();
+  const heads = S.selectedHeads;
+  const seqLen = S.seqLen || 8;
+  if (!heads.length) return;
+
+  const laneGap = 5.0;                       // z-separation between head lanes
+  const x0 = -((seqLen - 1) * 1.2) / 2;      // centre the timeline in x
+  const dx = 1.2;                            // x per token position
+  const yScale = 6.0;                        // world-units per unit attention mass (mass 0..1)
+
+  heads.forEach((h, li) => {
+    const z = (li - (heads.length - 1) / 2) * laneGap;
+    const tl = S.headTimelines[String(h)] || {};
+
+    // rail bar under each lane (selected-head accent)
+    const rail = new THREE.Mesh(
+      new THREE.BoxGeometry((seqLen - 1) * dx + 0.4, 0.06, 0.12),
+      new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.3, transparent: true, opacity: 0.55 }),
+    );
+    rail.position.set(0, 0.03, z);
+    rail.userData.head = h;
+    _group.add(rail); _rails.push(rail);
+
+    [["correct", C_CORRECT], ["incorrect", C_WRONG]].forEach(([regime, col]) => {
+      const series = Array.isArray(tl[regime]) ? tl[regime] : [];
+      if (!series.length) return;
+      const pts = [];
+      for (let i = 0; i < series.length; i++) {
+        const x = x0 + i * dx;
+        const y = Math.max(0.05, Math.min(series[i] * yScale, 8.5));
+        pts.push(new THREE.Vector3(x, y, z + (regime === "incorrect" ? 0.35 : -0.35)));
+        // marker node
+        const node = new THREE.Mesh(
+          new THREE.SphereGeometry(0.11, 12, 12),
+          new THREE.MeshStandardMaterial({ color: col, emissive: col, emissiveIntensity: 0.5 }),
+        );
+        node.position.copy(pts[pts.length - 1]);
+        node.userData.pi = _nodes.length % _MAX_NODES;
+        _group.add(node); _nodes.push(node);
+      }
+      const geo = new THREE.BufferGeometry().setFromPoints(pts);
+      const line = new THREE.Line(geo, new THREE.LineBasicMaterial({ color: col, transparent: true, opacity: 0.9 }));
+      line.userData.regime = regime;
+      _group.add(line); _lines.push(line);
+    });
+  });
+  _built = true;
+}
+
+// =============================================================================
+// live data handler — reads label VERBATIM (top-level 'label' OR nested 'payload.label')
+// =============================================================================
+function _onScore(j) {
+  const p = (j && typeof j.payload === "object" && j.payload) ? j.payload : j;
+  const rawLabel = (p && p.label != null) ? p.label : (j && j.label != null ? j.label : "MODELED");
+  S.label = String(rawLabel).toUpperCase();
+
+  S.seqLen    = typeof p.seq_len   === "number"  ? p.seq_len   : null;
+  S.threshold = typeof p.threshold === "number"  ? p.threshold : null;
+  S.beats     = typeof p.rauq_beats_baseline === "boolean" ? p.rauq_beats_baseline : null;
+  S.selectedHeads = Array.isArray(p.selected_heads) ? p.selected_heads.slice() : [];
+
+  // metrics
+  const rm = p.rauq_metrics || {}, bm = p.baseline_metrics || {};
+  const grab = (o, dst) => {
+    dst.auroc     = typeof o.auroc     === "number" ? o.auroc     : null;
+    dst.accuracy  = typeof o.accuracy  === "number" ? o.accuracy  : null;
+    dst.precision = typeof o.precision === "number" ? o.precision : null;
+    dst.recall    = typeof o.recall    === "number" ? o.recall    : null;
+    dst.f1        = typeof o.f1        === "number" ? o.f1        : null;
+  };
+  grab(rm, S.rauq); grab(bm, S.baseline);
+
+  // Extract one representative correct + one incorrect example's per-selected-head timeline.
+  S.headTimelines = {};
+  const exs = Array.isArray(p.examples) ? p.examples : [];
+  const firstCorrect = exs.find((e) => e && e.label === "correct");
+  const firstWrong   = exs.find((e) => e && e.label === "incorrect");
+  S.selectedHeads.forEach((h) => {
+    const key = String(h);
+    const tl = {};
+    if (firstCorrect && firstCorrect.selected_head_preceding_timeline && Array.isArray(firstCorrect.selected_head_preceding_timeline[key])) {
+      tl.correct = firstCorrect.selected_head_preceding_timeline[key].slice();
+    }
+    if (firstWrong && firstWrong.selected_head_preceding_timeline && Array.isArray(firstWrong.selected_head_preceding_timeline[key])) {
+      tl.incorrect = firstWrong.selected_head_preceding_timeline[key].slice();
+    }
+    S.headTimelines[key] = tl;
+  });
+
+  _buildTimelines();
+  _updateGeometry();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — colours by live/degraded state, verdict ring
+// =============================================================================
+function _updateGeometry() {
+  const live = S.state === "live";
+  _lines.forEach((ln) => {
+    const col = live ? (ln.userData.regime === "incorrect" ? C_WRONG : C_CORRECT) : C_DIM;
+    ln.material.color.setHex(col);
+    ln.material.opacity = live ? 0.9 : 0.3;
+  });
+  _nodes.forEach((nd) => {
+    if (!live) { nd.material.color.setHex(C_DIM); nd.material.emissive.setHex(C_DIM); nd.material.emissiveIntensity = 0.1; }
+  });
+  _rails.forEach((rl) => {
+    const col = live ? C_ACCENT : C_DIM;
+    rl.material.color.setHex(col); rl.material.emissive.setHex(col);
+    rl.material.emissiveIntensity = live ? 0.3 : 0.1; rl.material.opacity = live ? 0.55 : 0.2;
+  });
+  if (_ring) {
+    // verdict: RAUQ beats baseline -> calm teal; else violet-blue warning
+    const beats = S.beats === true;
+    const rcol = live ? (beats ? C_ACCENT : C_WRONG) : C_DIM;
+    _ring.material.color.setHex(rcol); _ring.material.emissive.setHex(rcol);
+    _ring.material.emissiveIntensity = live ? (beats ? 0.6 : 0.85) : 0.12;
+    _ring.material.opacity = live ? 0.6 : 0.2;
+    _ring.scale.setScalar(live ? (beats ? 1.0 : 1.15) : 0.8);
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.0001) * 0.12;
+  if (_ring) _ring.rotation.z += 0.004;
+  const live = S.state === "live";
+  _nodes.forEach((nd) => {
+    const i = nd.userData.pi;
+    if (_pulse[i] > 0) {
+      _pulse[i] -= 1;
+      const f = _pulse[i] / 60;
+      nd.material.emissiveIntensity = Math.max(nd.material.emissiveIntensity, 0.2 + 0.6 * f);
+    } else if (live) {
+      nd.material.emissiveIntensity = 0.4;
+    }
+  });
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,500px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'In a <b>single forward pass</b> we read a model\u2019s <b>attention patterns</b>: certain ' +
+    '<b>uncertainty-aware heads</b> keep high attention on the <b>immediately-preceding token</b> ' +
+    'when a generation is <b>correct</b>, but that mass <b>drops</b> when it is <b>incorrect</b>. ' +
+    'We <b>auto-select</b> those heads by how well they separate a labeled set, <b>recurrently ' +
+    'aggregate</b> their preceding-token attention with a confidence proxy into one ' +
+    '<b>sequence-level uncertainty score</b>, and <b>flag</b> likely-wrong generations \u2014 beating ' +
+    'a cheap <b>output-entropy</b> baseline. Sub-organ upgrade of <b>sement</b> (same uncertainty ' +
+    'axis; sement\u2019s true signal is <b>multi-sample</b> semantic entropy, this is ' +
+    '<b>single-pass attention</b>). Honesty label <b>MODELED</b> \u2014 a simulation of the method on ' +
+    'synthetic toy data, <b>not</b> a real transformer. 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "rauq \u00b7 attention-pattern uncertainty";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:62%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("rq-sel",   "auto-selected heads"));
+  grid.appendChild(kpiRow("rq-thr",   "RAUQ flag threshold"));
+  grid.appendChild(kpiRow("rq-ra",    "RAUQ \u00b7 AUROC / accuracy"));
+  grid.appendChild(kpiRow("rq-rf",    "RAUQ \u00b7 precision / recall / F1"));
+  grid.appendChild(kpiRow("rq-ba",    "baseline \u00b7 AUROC / accuracy"));
+  grid.appendChild(kpiRow("rq-bf",    "baseline \u00b7 precision / recall / F1"));
+  grid.appendChild(kpiRow("rq-beats", "attention-drop beats output-entropy"));
+  grid.appendChild(kpiRow("rq-label", "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Vazhentsev, Rvanova, Kuzmin, Fadeeva, Lazichny, Panchenko, Panov, Baldwin, " +
+    "Sachan, Nakov & Shelmanov, arXiv:2505.20045 (2025) \u00b7 MODELED \u00b7 seeded synthetic attention " +
+    "matrices, regimes built in by construction, no real transformer \u00b7 sub-organ upgrade of " +
+    "sement (true sement signal is multi-sample) \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "rauq-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const sel  = S.selectedHeads.length ? S.selectedHeads.join(", ") : "loading\u2026";
+  const rAuroc = S.rauq.auroc != null ? S.rauq.auroc.toFixed(3) : "loading\u2026";
+  const rAcc   = S.rauq.accuracy != null ? S.rauq.accuracy.toFixed(3) : "loading\u2026";
+  const bAuroc = S.baseline.auroc != null ? S.baseline.auroc.toFixed(3) : "loading\u2026";
+  const bAcc   = S.baseline.accuracy != null ? S.baseline.accuracy.toFixed(3) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> A transformer pays <b>attention</b> to earlier words as it writes. " +
+    "In some heads, when the model is on solid ground it keeps a strong link to the <b>word it just " +
+    "wrote</b>; when it starts to <b>make things up</b>, that link <b>weakens</b>. We find the heads " +
+    "where this pattern is clearest (here heads <b>" + sel + "</b>), watch how their preceding-word " +
+    "attention rises and falls across the sentence, and roll it into a single <b>uncertainty score</b> " +
+    "\u2014 all in <b>one pass</b>, no re-asking the model. On our labeled toy set that attention-drop " +
+    "score tells correct from incorrect almost perfectly (AUROC \u2248 <b>" + rAuroc + "</b>, accuracy " +
+    "\u2248 <b>" + rAcc + "</b>), while a naive <b>output-entropy</b> baseline is much weaker " +
+    "(AUROC \u2248 <b>" + bAuroc + "</b>, accuracy \u2248 <b>" + bAcc + "</b>). The blue timeline holds " +
+    "high; the violet timeline collapses \u2014 that collapse is the signal." +
+    "<br><br><b>Important honesty note:</b> this is a <b>MODELED</b> toy analytic simulation of the " +
+    "attention-pattern-uncertainty <b>mechanism</b>, <b>not RAUQ</b> and <b>not a real transformer</b>. " +
+    "The \u201cattention matrices\u201d are <b>seeded synthetic</b> row-stochastic toys with the " +
+    "correct/incorrect regimes <b>built in by construction</b>; there is <b>no forward pass</b> and " +
+    "<b>no 4-LLM / 12-task evaluation</b>, and \u201chead selection\u201d separates a <b>hand-made " +
+    "labeled toy set</b>. It shows <b>why</b> a drop in preceding-token attention can be a single-pass " +
+    "uncertainty signal that output-entropy misses, but it does <b>not</b> reproduce RAUQ\u2019s " +
+    "QA/summarization/translation results or its <b>&lt;1% latency</b> claim. It is explicitly a " +
+    "<b>sub-organ upgrade of sement</b> \u2014 same uncertainty axis, distinct <b>single-pass-attention</b> " +
+    "vs <b>multi-sample semantic-entropy</b> mechanism (the true sement signal is <b>multi-sample</b>) " +
+    "\u2014 not a new axis (Vazhentsev et al., arXiv:2505.20045, 2025).";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("rq-sel", t || (S.selectedHeads.length ? S.selectedHeads.join(", ") : "\u2014"));
+  _set("rq-thr", t || fx(S.threshold, 3));
+  _set("rq-ra",  t || (S.rauq.auroc != null && S.rauq.accuracy != null ? fx(S.rauq.auroc, 3) + " / " + fx(S.rauq.accuracy, 3) : "\u2014"));
+  _set("rq-rf",  t || (S.rauq.precision != null ? fx(S.rauq.precision, 3) + " / " + fx(S.rauq.recall, 3) + " / " + fx(S.rauq.f1, 3) : "\u2014"));
+  _set("rq-ba",  t || (S.baseline.auroc != null && S.baseline.accuracy != null ? fx(S.baseline.auroc, 3) + " / " + fx(S.baseline.accuracy, 3) : "\u2014"));
+  _set("rq-bf",  t || (S.baseline.precision != null ? fx(S.baseline.precision, 3) + " / " + fx(S.baseline.recall, 3) + " / " + fx(S.baseline.f1, 3) : "\u2014"));
+  _set("rq-beats", t || (S.beats == null ? "\u2014" : (S.beats ? "YES \u2014 attention-drop separates better" : "no")));
+  // honesty label verbatim — never upgraded
+  _set("rq-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _lines = []; _nodes = []; _rails = []; _ring = null;
+  _built = false;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.seqLen = S.threshold = S.beats = null;
+  S.selectedHeads = []; S.headTimelines = {};
+  S.rauq = { auroc: null, accuracy: null, precision: null, recall: null, f1: null };
+  S.baseline = { auroc: null, accuracy: null, precision: null, recall: null, f1: null };
+  S.state = "init";
+  _pulse.fill(0);
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/slidesparse.js

@@ -0,0 +1,616 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/slidesparse.js — STRUCTURED-SPARSE LAYOUT PACKING organ for the
+// holographic frontier ring (SlideSparse (2N-2):2N sliding-window decomposition
+// + activation lifting, Furu Wei group-style). Renders one 2N-wide structured-
+// sparse weight block as a row of cells, then lifts it into N-1 OVERLAPPING
+// 4-wide 2:4 windows stacked above it — each window 2:4-compliant (<=2 nonzeros
+// per 4) — visually showing that the N-1 windows recompose the block EXACTLY
+// (lossless). A throughput-proxy bar trio compares dense (lattice-blue), strict-
+// 2:4 (grey/over-pruned) and slidesparse (proof-teal) effective-MAC speedups
+// against the N/(N-1) ceiling read live from /api/killinchu/v1/slidesparse/pack.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is; it
+// is never upgraded.
+//
+// Surface export shape (mirrors ternary.js / aimc.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   N, block_width, windows_per_block, sparsity_pattern, prune_fraction,
+//   matrix_rows, matrix_cols, blocks_total, mode, reconstruction_error, lossless,
+//   slidesparse_recon_error, strict_2to4_recon_error, dense_macs,
+//   strict_2to4_macs, slidesparse_macs, speedup_dense, speedup_strict_2to4,
+//   speedup_slidesparse, throughput_ceiling, ceiling_gap,
+//   activation_lifting_perm[], sample_window_masks[]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   SlideSparse: Fast and Flexible (2N-2):2N Structured Sparsity (mechanism
+//   simulated here):
+//     Shao, Hao, Song, Xia, Zhang, Huang, Wu, Xu, Xu, Dong, Chi, Zou, Wei
+//     (Furu Wei group)  arXiv:2603.05232  https://arxiv.org/abs/2603.05232
+//
+// HONESTY LABELS: MODELED (deterministic reproduction of the SlideSparse sliding-
+//   window-decomposition + activation-lifting PACKING mechanism on a toy synthetic
+//   matrix; NO GPU, NO Sparse Tensor Core, NO vLLM, NO CUDA; 'throughput' is a
+//   counted MAC proxy, 'accuracy' a reconstruction-error proxy; NEVER-CLAIMED-AS a
+//   real tensor-core run or SlideSparse's 1.33x Qwen2.5-7B result). Read verbatim
+//   from JSON; never upgraded here. NEW AXIS: structured-sparse layout/packing —
+//   orthogonal to ternary bit-precision + aimc analog compute.
+// COLOURS: proof-teal 0x3af4c8 (slidesparse path / kept nonzero / HUD accent),
+//   lattice-blue 0x5b8dee (dense baseline / block cells), violet-blue 0x8a6bff
+//   (window frame / activation-lifting accent), greys (pruned zeros / strict-2:4
+//   over-prune / degraded state). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js via ctx.THREE (page importmap).
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "slidesparse";
+const TITLE = "Structured-Sparse Layout Packing · SlideSparse (2N-2):2N (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship).
+// This keeps the slidesparse organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/slidesparse/pack?seed=42&N=4&mode=slidesparse";
+
+// data-viz hues — purple BANNED
+const C_SLIDE   = 0x3af4c8;  // proof-teal (slidesparse path / kept nonzero)
+const C_DENSE   = 0x5b8dee;  // lattice-blue (dense baseline / block cell)
+const C_WINDOW  = 0x8a6bff;  // violet-blue (window frame / activation-lifting)
+const C_PRUNE   = 0x5a6570;  // grey (pruned zero / dropped weight)
+const C_STRICT  = 0x6b7a86;  // grey (strict-2:4 over-pruned baseline)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const MAX_BLOCK   = 32;    // cap on block cells rendered (perf): 2N <= MAX_BLOCK
+const MAX_WINDOWS = 15;    // cap on windows rendered (perf): N-1 <= MAX_WINDOWS
+const CELL_GAP    = 0.6;   // world-units between block cells along X
+const WIN_Y_GAP   = 0.62;  // vertical spacing between stacked windows
+const BLOCK_Y     = 0.4;   // resting height of the source block row
+const MAX_BAR_H   = 4.2;   // world-units — throughput bar height at ceiling
+const MIN_BAR_H   = 0.04;  // floor height so a bar never fully vanishes
+const BAR_GAP     = 1.1;   // spacing between the three throughput bars
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _floor     = null;
+let _blockCell = [];                 // Array<THREE.Mesh> — the 2N source-block cells
+let _winCell   = [];                 // Array<Array<THREE.Mesh>> — window x 4 cells
+let _winFrame  = [];                 // Array<THREE.LineSegments> — window frames
+let _barDense  = null;               // THREE.Mesh — dense speedup bar
+let _barStrict = null;               // THREE.Mesh — strict-2:4 speedup bar
+let _barSlide  = null;               // THREE.Mesh — slidesparse speedup bar
+let _ceilLine  = null;               // THREE.Line — N/(N-1) ceiling marker
+let _liftMark  = null;               // THREE.Mesh — activation-lifting pulse marker
+
+// live state
+const S = {
+  label:        null,
+  N:            null,
+  blockWidth:   null,   // block_width (2N)
+  winsPerBlock: null,   // windows_per_block (N-1)
+  pattern:      null,   // sparsity_pattern e.g. "6:8"
+  pruneFrac:    null,   // prune_fraction
+  rows:         null,   // matrix_rows
+  cols:         null,   // matrix_cols
+  blocksTotal:  null,   // blocks_total
+  mode:         null,   // mode
+  reconErr:     null,   // reconstruction_error (for mode)
+  lossless:     null,   // lossless
+  slideRecon:   null,   // slidesparse_recon_error
+  strictRecon:  null,   // strict_2to4_recon_error
+  denseMacs:    null,   // dense_macs
+  strictMacs:   null,   // strict_2to4_macs
+  slideMacs:    null,   // slidesparse_macs
+  spDense:      null,   // speedup_dense
+  spStrict:     null,   // speedup_strict_2to4
+  spSlide:      null,   // speedup_slidesparse
+  ceiling:      null,   // throughput_ceiling N/(N-1)
+  ceilingGap:   null,   // ceiling_gap
+  liftPerm:     null,   // activation_lifting_perm[]
+  winMasks:     null,   // sample_window_masks[]
+  state:        "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(4, 7, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(3, 2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildBlock();
+  _buildWindows();
+  _buildBars();
+  _buildLiftMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onSlide, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// The 2N-wide structured-sparse source block: a row of cells along X. Kept
+// nonzeros glow lattice-blue; the 2 dropped (pruned) entries fade to grey and
+// sink. Coloured in-place from the live window masks (no per-poll churn).
+function _buildBlock() {
+  const THREE = _THREE;
+  const cellGeo = new THREE.BoxGeometry(0.34, 0.34, 0.34);
+  for (let i = 0; i < MAX_BLOCK; i++) {
+    const mesh = new THREE.Mesh(
+      cellGeo,
+      new THREE.MeshStandardMaterial({ color: C_PRUNE, emissive: C_PRUNE, emissiveIntensity: 0.15, transparent: true, opacity: 0.0 }),
+    );
+    mesh.position.set(i * CELL_GAP, BLOCK_Y, 0);
+    mesh.visible = false;
+    _group.add(mesh);
+    _blockCell.push(mesh);
+  }
+}
+
+// N-1 overlapping 4-wide 2:4 windows, stacked upward above the source block.
+// Each window is a violet-blue wireframe frame around its 4 cells; kept nonzeros
+// in a window glow proof-teal, empty slots stay grey. Positioned at the window's
+// column offset so it visually overlays the exact columns it recomposes.
+function _buildWindows() {
+  const THREE = _THREE;
+  const cellGeo = new THREE.BoxGeometry(0.28, 0.28, 0.28);
+  for (let w = 0; w < MAX_WINDOWS; w++) {
+    const row = [];
+    for (let k = 0; k < 4; k++) {
+      const mesh = new THREE.Mesh(
+        cellGeo,
+        new THREE.MeshStandardMaterial({ color: C_PRUNE, emissive: C_PRUNE, emissiveIntensity: 0.12, transparent: true, opacity: 0.0 }),
+      );
+      mesh.visible = false;
+      _group.add(mesh);
+      row.push(mesh);
+    }
+    _winCell.push(row);
+
+    // window frame (violet-blue wireframe box spanning the 4-wide window)
+    const frameGeo = new THREE.BoxGeometry(4 * CELL_GAP, 0.5, 0.5);
+    const edges = new THREE.EdgesGeometry(frameGeo);
+    const frame = new THREE.LineSegments(
+      edges,
+      new THREE.LineBasicMaterial({ color: C_WINDOW, transparent: true, opacity: 0.0 }),
+    );
+    frame.visible = false;
+    _group.add(frame);
+    _winFrame.push(frame);
+  }
+}
+
+// Three throughput-proxy bars (dense / strict-2:4 / slidesparse effective-MAC
+// speedup) plus a horizontal N/(N-1) ceiling marker line the slidesparse bar
+// should reach but never exceed.
+function _buildBars() {
+  const THREE = _THREE;
+  const barGeo = new THREE.BoxGeometry(0.5, 1, 0.5);
+  barGeo.translate(0, 0.5, 0); // base at y=0; scaling Y grows upward
+
+  function mkBar(color, emis) {
+    const m = new THREE.Mesh(
+      barGeo,
+      new THREE.MeshStandardMaterial({ color, emissive: color, emissiveIntensity: emis, transparent: true, opacity: 0.9 }),
+    );
+    m.scale.set(1, MIN_BAR_H, 1);
+    m.visible = false;
+    _group.add(m);
+    return m;
+  }
+  const baseX = -3.2, baseZ = -3.0;
+  _barDense  = mkBar(C_DENSE, 0.3);  _barDense.position.set(baseX,               0, baseZ);
+  _barStrict = mkBar(C_STRICT, 0.25); _barStrict.position.set(baseX + BAR_GAP,   0, baseZ);
+  _barSlide  = mkBar(C_SLIDE, 0.45); _barSlide.position.set(baseX + 2 * BAR_GAP, 0, baseZ);
+
+  const pts = [
+    new THREE.Vector3(baseX - 0.5, MIN_BAR_H, baseZ),
+    new THREE.Vector3(baseX + 2 * BAR_GAP + 0.5, MIN_BAR_H, baseZ),
+  ];
+  const geo = new THREE.BufferGeometry().setFromPoints(pts);
+  _ceilLine = new THREE.Line(geo, new THREE.LineBasicMaterial({ color: C_WINDOW, transparent: true, opacity: 0.6 }));
+  _group.add(_ceilLine);
+}
+
+function _buildLiftMarker() {
+  const THREE = _THREE;
+  _liftMark = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.3, 1),
+    new THREE.MeshStandardMaterial({ color: C_WINDOW, emissive: C_WINDOW, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _liftMark.position.set(-1.2, 1.4, 2.2);
+  _group.add(_liftMark);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onSlide(j) {
+  // read honesty label VERBATIM — never upgrade. handle top-level 'label' OR
+  // nested 'payload.label' to match our own module's shape.
+  const lbl = (j && j.label != null) ? j.label
+            : (j && j.payload && j.payload.label != null) ? j.payload.label
+            : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : j;
+
+  S.label        = String(lbl).toUpperCase();
+  S.N            = typeof src.N                       === "number" ? src.N                       : null;
+  S.blockWidth   = typeof src.block_width             === "number" ? src.block_width             : null;
+  S.winsPerBlock = typeof src.windows_per_block       === "number" ? src.windows_per_block       : null;
+  S.pattern      = typeof src.sparsity_pattern        === "string" ? src.sparsity_pattern        : null;
+  S.pruneFrac    = typeof src.prune_fraction          === "number" ? src.prune_fraction          : null;
+  S.rows         = typeof src.matrix_rows             === "number" ? src.matrix_rows             : null;
+  S.cols         = typeof src.matrix_cols             === "number" ? src.matrix_cols             : null;
+  S.blocksTotal  = typeof src.blocks_total            === "number" ? src.blocks_total            : null;
+  S.mode         = typeof src.mode                    === "string" ? src.mode                    : null;
+  S.reconErr     = typeof src.reconstruction_error    === "number" ? src.reconstruction_error    : null;
+  S.lossless     = typeof src.lossless                === "boolean" ? src.lossless               : null;
+  S.slideRecon   = typeof src.slidesparse_recon_error === "number" ? src.slidesparse_recon_error : null;
+  S.strictRecon  = typeof src.strict_2to4_recon_error === "number" ? src.strict_2to4_recon_error : null;
+  S.denseMacs    = typeof src.dense_macs              === "number" ? src.dense_macs              : null;
+  S.strictMacs   = typeof src.strict_2to4_macs        === "number" ? src.strict_2to4_macs        : null;
+  S.slideMacs    = typeof src.slidesparse_macs        === "number" ? src.slidesparse_macs        : null;
+  S.spDense      = typeof src.speedup_dense           === "number" ? src.speedup_dense           : null;
+  S.spStrict     = typeof src.speedup_strict_2to4     === "number" ? src.speedup_strict_2to4     : null;
+  S.spSlide      = typeof src.speedup_slidesparse     === "number" ? src.speedup_slidesparse     : null;
+  S.ceiling      = typeof src.throughput_ceiling      === "number" ? src.throughput_ceiling      : null;
+  S.ceilingGap   = typeof src.ceiling_gap             === "number" ? src.ceiling_gap             : null;
+  S.liftPerm     = Array.isArray(src.activation_lifting_perm) ? src.activation_lifting_perm : null;
+  S.winMasks     = Array.isArray(src.sample_window_masks)     ? src.sample_window_masks     : null;
+
+  _updateBlock();
+  _updateWindows();
+  _updateBars();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updaters
+// =============================================================================
+// Which block columns are kept (nonzero)? Derive from the live window masks:
+// every column that appears (mask=1) in some window is a kept nonzero; the rest
+// are the pruned/dropped entries. Client never invents structure it cannot see.
+function _keptColumns() {
+  const kept = {};
+  if (!S.winMasks) return kept;
+  for (const win of S.winMasks) {
+    if (!win || !Array.isArray(win.mask)) continue;
+    const off = typeof win.offset === "number" ? win.offset : 0;
+    for (let k = 0; k < 4; k++) {
+      if (win.mask[k]) kept[off + k] = true;
+    }
+  }
+  return kept;
+}
+
+function _updateBlock() {
+  const live = S.state === "live";
+  const width = live && S.blockWidth ? Math.min(S.blockWidth, MAX_BLOCK) : 0;
+  const kept = _keptColumns();
+  for (let i = 0; i < MAX_BLOCK; i++) {
+    const mesh = _blockCell[i];
+    if (!live || i >= width) { mesh.visible = false; continue; }
+    mesh.visible = true;
+    const isKept = kept[i] === true;
+    const color = isKept ? C_DENSE : C_PRUNE;   // kept -> lattice-blue; dropped -> grey
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = isKept ? 0.5 : 0.12;
+    mesh.material.opacity = isKept ? 0.95 : 0.3;
+    mesh.position.y = isKept ? BLOCK_Y : BLOCK_Y - 0.3;  // dropped entries sink
+  }
+}
+
+function _updateWindows() {
+  const live = S.state === "live";
+  const masks = live && S.winMasks ? S.winMasks : [];
+  for (let w = 0; w < MAX_WINDOWS; w++) {
+    const has = live && w < masks.length;
+    const row = _winCell[w];
+    const frame = _winFrame[w];
+    if (!has) {
+      for (let k = 0; k < 4; k++) row[k].visible = false;
+      frame.visible = false;
+      continue;
+    }
+    const win = masks[w];
+    const off = typeof win.offset === "number" ? win.offset : 0;
+    const yLevel = BLOCK_Y + (w + 1) * WIN_Y_GAP + 0.6;
+    for (let k = 0; k < 4; k++) {
+      const mesh = row[k];
+      mesh.visible = true;
+      const on = win.mask && win.mask[k];
+      const color = on ? C_SLIDE : C_PRUNE;   // kept nonzero -> proof-teal; empty -> grey
+      mesh.material.color.setHex(color);
+      mesh.material.emissive.setHex(color);
+      mesh.material.emissiveIntensity = on ? 0.55 : 0.1;
+      mesh.material.opacity = on ? 0.95 : 0.2;
+      mesh.position.set((off + k) * CELL_GAP, yLevel, 0);
+    }
+    frame.visible = true;
+    frame.material.opacity = 0.45;
+    frame.position.set((off + 1.5) * CELL_GAP, yLevel, 0);
+  }
+}
+
+function _updateBars() {
+  const live = S.state === "live";
+  const ceiling = live && typeof S.ceiling === "number" && S.ceiling > 0 ? S.ceiling : 1.0;
+  // scale so the N/(N-1) ceiling sits at MAX_BAR_H; dense (1.0) is the reference.
+  const scaleFor = (v) => {
+    if (typeof v !== "number") return MIN_BAR_H;
+    return Math.max(MIN_BAR_H, (v / ceiling) * MAX_BAR_H);
+  };
+
+  const showBar = (bar, v, colorLive) => {
+    bar.visible = live;
+    if (!live) return;
+    bar.scale.y = scaleFor(v);
+    const c = live ? colorLive : C_DIM;
+    bar.material.color.setHex(c);
+    bar.material.emissive.setHex(c);
+  };
+  showBar(_barDense,  S.spDense,  C_DENSE);
+  showBar(_barStrict, S.spStrict, C_STRICT);
+  showBar(_barSlide,  S.spSlide,  C_SLIDE);
+
+  if (_ceilLine) {
+    // ceiling marker sits at MAX_BAR_H (the N/(N-1) line)
+    _ceilLine.position.y = live ? MAX_BAR_H : MIN_BAR_H;
+    _ceilLine.material.opacity = live ? 0.6 : 0.12;
+    _ceilLine.material.color.setHex(live ? C_WINDOW : C_DIM);
+  }
+  if (_liftMark) {
+    const c = live ? C_WINDOW : C_DIM;
+    _liftMark.material.color.setHex(c);
+    _liftMark.material.emissive.setHex(c);
+    _liftMark.material.opacity = live ? 0.85 : 0.3;
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.12;
+  if (_liftMark) {
+    _liftMark.rotation.y += 0.024;
+    _liftMark.rotation.x += 0.011;
+    const pulse = 1.0 + 0.15 * Math.sin(t * 0.004);
+    _liftMark.scale.setScalar(pulse);
+  }
+  // gentle upward shimmer on the window cells to suggest the lift/decomposition
+  for (let w = 0; w < _winCell.length; w++) {
+    const row = _winCell[w];
+    for (let k = 0; k < 4; k++) {
+      const m = row[k];
+      if (m.visible) m.material.emissiveIntensity = 0.2 + 0.2 * (0.5 + 0.5 * Math.sin(t * 0.003 + (w * 4 + k) * 0.5));
+    }
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,470px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'NVIDIA Sparse Tensor Cores accelerate ONLY the rigid <b>2:4</b> pattern (50% prune) \u2014 often ' +
+    'too harsh for accuracy. Milder <b>(2N-2):2N</b> patterns (e.g. <b>6:8</b>, 25% prune) keep ' +
+    'accuracy but get no hardware support. SlideSparse is a pure <b>data-layout / packing</b> ' +
+    'transform: a <b>sliding-window decomposition</b> splits each (2N-2):2N block into <b>N-1 ' +
+    'overlapping 4-wide 2:4 windows</b> that recompose the block <b>EXACTLY</b> (lossless), so mild ' +
+    'sparsity runs on existing 2:4 cores; <b>activation lifting</b> fuses the matching activation ' +
+    'rearrangement. Honesty label <b>MODELED</b> \u2014 a toy counted-MAC proxy, NOT a GPU/tensor-core ' +
+    'run. 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#3af4c8;box-shadow:0 0 7px #3af4c8";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#3af4c8;letter-spacing:.3px";
+  nm.textContent = "structured-sparse layout packing";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:56%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("ss-pattern",  "sparsity pattern (2N-2):2N"));
+  grid.appendChild(kpiRow("ss-block",    "block width (2N)"));
+  grid.appendChild(kpiRow("ss-wins",     "windows / block (N-1)"));
+  grid.appendChild(kpiRow("ss-prune",    "prune fraction"));
+  grid.appendChild(kpiRow("ss-blocks",   "blocks packed"));
+  grid.appendChild(kpiRow("ss-slrecon",  "RECON \u2014 slidesparse error (EXACT)"));
+  grid.appendChild(kpiRow("ss-strecon",  "RECON \u2014 strict-2:4 error (baseline)"));
+  grid.appendChild(kpiRow("ss-lossless", "lossless reconstruction"));
+  grid.appendChild(kpiRow("ss-spstrict", "THROUGHPUT \u2014 strict-2:4 speedup"));
+  grid.appendChild(kpiRow("ss-spslide",  "THROUGHPUT \u2014 slidesparse speedup"));
+  grid.appendChild(kpiRow("ss-ceiling",  "ceiling N/(N-1) \u2014 MODELED proxy"));
+  grid.appendChild(kpiRow("ss-gap",      "gap to ceiling"));
+  grid.appendChild(kpiRow("ss-label",    "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "SlideSparse: Fast and Flexible (2N-2):2N Structured Sparsity \u2014 Shao, Hao, Song, Xia, Zhang, Huang, Wu, Xu, Xu, Dong, Chi, Zou, Wei (Furu Wei group) arXiv:2603.05232. MODELED \u00b7 not claimed-as \u00b7 counted-MAC proxy, not a GPU/tensor-core run.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "ss-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const pat   = S.pattern    != null ? S.pattern : "loading\u2026";
+  const wins  = S.winsPerBlock != null ? String(S.winsPerBlock) : "loading\u2026";
+  const spd   = S.spSlide    != null ? S.spSlide.toFixed(2) + "\u00d7" : "loading\u2026";
+  const ceil  = S.ceiling    != null ? S.ceiling.toFixed(2) + "\u00d7" : "loading\u2026";
+  const strErr = S.strictRecon != null ? S.strictRecon.toFixed(3) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Modern AI chips have a special fast path that only works if you delete " +
+    "exactly half of the numbers in a very rigid on/off pattern (\u201c2:4\u201d). Deleting half is often too " +
+    "aggressive and hurts the model, so people use gentler patterns like <b>" + pat + "</b> (deleting " +
+    "only a quarter) \u2014 but then the fast path won\u2019t take them, and the chip falls back to the slow " +
+    "route. <b>SlideSparse</b> is a clever re-packing trick: it slices each gentle-sparsity block into " +
+    "<b>" + wins + "</b> small overlapping windows that each DO obey the rigid 2:4 rule, and those windows " +
+    "add back up to the original block <b>with zero error</b> \u2014 so you keep the accuracy of gentle " +
+    "pruning AND regain the hardware fast path. Here the fast path reaches about <b>" + spd + "</b> speed " +
+    "(its theoretical ceiling is <b>" + ceil + "</b>), while forcing the rigid 2:4 pattern instead would " +
+    "corrupt the weights (reconstruction error \u2248 <b>" + strErr + "</b>). <b>Important honesty note:</b> " +
+    "this is a <b>MODELED</b> toy on a small synthetic matrix running on an ordinary CPU \u2014 there is " +
+    "<b>NO GPU, NO Sparse Tensor Core, NO CUDA, NO vLLM</b>; \u201cspeed\u201d here is a counted " +
+    "multiply-accumulate proxy, not a hardware measurement. It does NOT reproduce SlideSparse\u2019s " +
+    "reported 1.33\u00d7 speedup on Qwen2.5-7B or its real GPU results. This is a <b>new axis</b> \u2014 " +
+    "structured-sparse layout/packing \u2014 separate from the ternary bit-precision and analog in-memory " +
+    "compute organs.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("ss-pattern",  t || (S.pattern != null ? S.pattern : "\u2014"));
+  _set("ss-block",    t || (S.blockWidth != null ? String(S.blockWidth) : "\u2014"));
+  _set("ss-wins",     t || (S.winsPerBlock != null ? String(S.winsPerBlock) : "\u2014"));
+  _set("ss-prune",    t || (S.pruneFrac != null ? (S.pruneFrac * 100).toFixed(1) + "%" : "\u2014"));
+  _set("ss-blocks",   t || (S.blocksTotal != null ? S.blocksTotal.toLocaleString() : "\u2014"));
+  _set("ss-slrecon",  t || (S.slideRecon != null ? S.slideRecon.toFixed(6) : "\u2014"));
+  _set("ss-strecon",  t || fx(S.strictRecon, 6));
+  _set("ss-lossless", t || (S.lossless != null ? (S.lossless ? "YES (zero error)" : "no") : "\u2014"));
+  _set("ss-spstrict", t || (S.spStrict != null ? S.spStrict.toFixed(3) + "\u00d7" : "\u2014"));
+  _set("ss-spslide",  t || (S.spSlide != null ? S.spSlide.toFixed(3) + "\u00d7" : "\u2014"));
+  _set("ss-ceiling",  t || (S.ceiling != null ? S.ceiling.toFixed(3) + "\u00d7" : "\u2014"));
+  _set("ss-gap",      t || (S.ceilingGap != null ? S.ceilingGap.toFixed(6) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("ss-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _floor = null; _blockCell = []; _winCell = []; _winFrame = [];
+  _barDense = _barStrict = _barSlide = _ceilLine = _liftMark = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.N = S.blockWidth = S.winsPerBlock = S.pattern = S.pruneFrac = null;
+  S.rows = S.cols = S.blocksTotal = S.mode = null;
+  S.reconErr = S.lossless = S.slideRecon = S.strictRecon = null;
+  S.denseMacs = S.strictMacs = S.slideMacs = null;
+  S.spDense = S.spStrict = S.spSlide = S.ceiling = S.ceilingGap = null;
+  S.liftPerm = S.winMasks = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };