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

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy main.
Files: 878 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

@@ -153,6 +153,9 @@ const SURFACES = [
   { id: "muon",        title: "Muon Orthogonalized-Momentum Optimizer", mod: "/static/3d/surfaces/muon.js" },
   { id: "specexec",    title: "Tree Speculative Execution",             mod: "/static/3d/surfaces/specexec.js" },
   { id: "nvfp4",       title: "NVFP4 4-bit Training Format",            mod: "/static/3d/surfaces/nvfp4.js" },
+  { id: "keyless",     title: "Keyless Attention (Value-Only Cache)",     mod: "/static/3d/surfaces/keyless.js" },
+  { id: "gitthoughts", title: "GitOfThoughts (Version-Controlled Reasoning)", mod: "/static/3d/surfaces/gitthoughts.js" },
+  { id: "herotq",      title: "HeRo-Q Hessian-Conditioned Quantization",    mod: "/static/3d/surfaces/herotq.js" },
 ];
 
 const stageEl = document.getElementById("stage");

static/3d/surfaces/gitthoughts.js

@@ -0,0 +1,650 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/gitthoughts.js — GITOFTHOUGHTS VERSION-CONTROLLED REASONING MEMORY
+// organ for the holographic frontier ring (GitOfThoughts = an agent's reasoning
+// tree stored as a git repository: every scored thought is a COMMIT, scores are
+// NOTES, terminal outcomes are TAGS, retrieval is `git log`; Shekar, Abhishek H S,
+// Krishnan, arXiv:2606.14470). Renders the live snapshot as three panels:
+//   (1) COMMIT TREE — the scored reasoning tree as a 3D branching DAG; each
+//       thought is a commit node coloured by outcome tag (solved / partial /
+//       dead-end), edges are parent links, and the HEAD->root `git log` branch
+//       is highlighted in proof-teal;
+//   (2) COPYABILITY THRESHOLD CURVE — retrieval accuracy vs case-similarity as a
+//       3D line with the ~0.8 threshold plane, honestly showing the SHARP jump
+//       (near-duplicate = answer retrieval) and the ~0 gain below it;
+//   (3) DIFF / MERGE BARS — only-A / shared / only-B commit counts and the merged
+//       commit count with any conflict slots.
+// A HUD reports the MEASURED metrics from /api/killinchu/v1/gitthoughts/tree.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is;
+// it is never upgraded.
+//
+// Surface export shape (mirrors muon.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   depth, branch, commit_count, leaf_count, head_sha, root_sha,
+//   git_log[{sha7,depth,score,note,tag,content}], replay_ok, replay_len,
+//   diff{only_a_count,shared_count,only_b_count,...}, merge{merged_commit_count,
+//   conflict_count,...}, tag_histogram{solved,partial,dead-end}, threshold,
+//   sweep[{similarity,accuracy,baseline,gain}], jump_size,
+//   gain_below_threshold, gain_above_threshold
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   GitOfThoughts: Version-Controlled Reasoning and Agent Memory You Can Replay,
+//     Diff, and Merge — Pavan C Shekar, Abhishek H S, Aswanth Krishnan.
+//     https://arxiv.org/abs/2606.14470
+//   Git content-addressed object model (Merkle DAG of commits) — Pro Git:
+//     https://git-scm.com/book/en/v2/Git-Internals-Git-Objects
+//
+// HONESTY LABELS: MODELED (deterministic reproduction of the GitOfThoughts DATA
+//   STRUCTURE — commit/note/tag/log/replay/diff/merge — plus the copyability-
+//   threshold finding on a synthetic case bank; runs NO real LLM; reasons
+//   nothing; the ~0 below-threshold gain is MEASURED and displayed; the paper's
+//   honest headline — memory does NOT improve novel-problem accuracy — is
+//   reproduced; NEVER-CLAIMED-AS a real agent-memory system). Read verbatim.
+// COLOURS: lattice-blue 0x5b8dee, violet-blue 0x8a6bff, proof-teal 0x3af4c8,
+//   greys (0x5a6570 / 0x42505d). 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    = "gitthoughts";
+const TITLE = "GitOfThoughts (Version-Controlled Reasoning)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute),
+// reached cross-origin (killinchu returns access-control-allow-origin).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/gitthoughts/tree?seed=42&depth=4&branch=3";
+
+// data-viz hues — purple BANNED
+const C_SOLVED  = 0x3af4c8;  // proof-teal   (outcome tag: solved / HEAD branch)
+const C_PARTIAL = 0x5b8dee;  // lattice-blue (outcome tag: partial)
+const C_DEAD    = 0x5a6570;  // grey         (outcome tag: dead-end)
+const C_INNER   = 0x42505d;  // grey         (non-leaf commit node)
+const C_EDGE    = 0x1b3a44;  // link / floor colour (parent edges)
+const C_HEAD    = 0x3af4c8;  // proof-teal   (HEAD->root git-log branch highlight)
+const C_CURVE   = 0x5b8dee;  // lattice-blue (accuracy curve below threshold)
+const C_CURVEHI = 0x3af4c8;  // proof-teal   (accuracy curve above threshold)
+const C_THRESH  = 0x8a6bff;  // violet-blue  (~0.8 threshold plane)
+const C_BASE    = 0x5a6570;  // grey         (no-memory baseline line)
+const C_ONLYA   = 0x5b8dee;  // lattice-blue (diff: only-A commits)
+const C_SHARED  = 0x8a6bff;  // violet-blue  (diff: shared commits)
+const C_ONLYB   = 0x3af4c8;  // proof-teal   (diff: only-B commits)
+const C_MERGE   = 0x3af4c8;  // proof-teal   (merged commit count)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+
+// layout geometry
+const TREE_DY   = 1.5;    // vertical world-units per tree depth level
+const TREE_SPAN = 9.0;    // horizontal span of the widest tree level
+const NODE_R    = 0.09;   // commit node sphere radius
+const CURVE_X0  = 7.0;    // threshold-curve panel origin x
+const CURVE_W   = 5.0;    // curve panel width (similarity 0..1)
+const CURVE_H   = 3.2;    // curve panel height (accuracy 0..1)
+const BAR_W     = 0.7;    // diff/merge bar width
+const BAR_YSC   = 0.32;   // world-units per commit in the 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 _treeGroup  = null;   // THREE.Group — commit tree nodes + edges + HEAD branch
+let _curveGroup = null;   // THREE.Group — copyability threshold curve + planes
+let _barGroup   = null;   // THREE.Group — diff/merge bars
+
+// live state
+const S = {
+  label:       null,
+  depth:       null,
+  branch:      null,
+  commitCount: null,   // commit_count
+  leafCount:   null,   // leaf_count
+  headSha:     null,   // head_sha
+  rootSha:     null,   // root_sha
+  gitLog:      null,   // Array<{sha7,depth,score,tag,content}>
+  replayOk:    null,   // replay_ok
+  replayLen:   null,   // replay_len
+  diff:        null,   // {only_a_count,shared_count,only_b_count,...}
+  merge:       null,   // {merged_commit_count,conflict_count,...}
+  tagHist:     null,   // {solved,partial,"dead-end"}
+  threshold:   null,   // ~0.8
+  sweep:       null,   // Array<{similarity,accuracy,baseline,gain}>
+  jumpSize:    null,   // jump_size
+  gainBelow:   null,   // gain_below_threshold
+  gainAbove:   null,   // gain_above_threshold
+  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, 6, 18);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(3, 1.0, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildTree();
+  _buildCurve();
+  _buildBars();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onGit, { badge: _badge, onState: (msg) => { S.state = msg.state; _updateAll(); _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(44, 44, C_EDGE, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// commit-tree panel: nodes/edges are rebuilt in place whenever fresh data
+// arrives (node count depends on live depth/branch). Group is pre-created here.
+function _buildTree() {
+  const THREE = _THREE;
+  _treeGroup = new THREE.Group();
+  _treeGroup.position.set(-2.0, 0.2, 0);
+  _group.add(_treeGroup);
+}
+
+// copyability threshold curve panel — the curve line + threshold plane + baseline
+// are rebuilt in _updateCurve once the live sweep/threshold are known.
+function _buildCurve() {
+  const THREE = _THREE;
+  _curveGroup = new THREE.Group();
+  _curveGroup.position.set(CURVE_X0, 0.0, -2.5);
+  _group.add(_curveGroup);
+}
+
+// diff/merge bars — heights set live in _updateBars.
+function _buildBars() {
+  const THREE = _THREE;
+  _barGroup = new THREE.Group();
+  _barGroup.position.set(CURVE_X0 + 0.4, 0, 3.6);
+  _group.add(_barGroup);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onGit(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.depth       = typeof src.depth        === "number" ? src.depth        : null;
+  S.branch      = typeof src.branch       === "number" ? src.branch       : null;
+  S.commitCount = typeof src.commit_count === "number" ? src.commit_count : null;
+  S.leafCount   = typeof src.leaf_count   === "number" ? src.leaf_count   : null;
+  S.headSha     = typeof src.head_sha     === "string" ? src.head_sha     : null;
+  S.rootSha     = typeof src.root_sha     === "string" ? src.root_sha     : null;
+  S.replayOk    = (typeof src.replay_ok   === "boolean") ? src.replay_ok  : null;
+  S.replayLen   = typeof src.replay_len   === "number" ? src.replay_len   : null;
+  S.threshold   = typeof src.threshold    === "number" ? src.threshold    : null;
+  S.jumpSize    = typeof src.jump_size    === "number" ? src.jump_size    : null;
+  S.gainBelow   = typeof src.gain_below_threshold === "number" ? src.gain_below_threshold : null;
+  S.gainAbove   = typeof src.gain_above_threshold === "number" ? src.gain_above_threshold : null;
+
+  S.gitLog  = Array.isArray(src.git_log) ? src.git_log : null;
+  S.sweep   = Array.isArray(src.sweep)   ? src.sweep   : null;
+  S.diff    = (src.diff  && typeof src.diff  === "object") ? src.diff  : null;
+  S.merge   = (src.merge && typeof src.merge === "object") ? src.merge : null;
+  S.tagHist = (src.tag_histogram && typeof src.tag_histogram === "object") ? src.tag_histogram : null;
+
+  _updateAll();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updaters
+// =============================================================================
+function _updateAll() {
+  _updateTree();
+  _updateCurve();
+  _updateBars();
+}
+
+function _disposeChildren(grp) {
+  if (!grp) return;
+  for (let i = grp.children.length - 1; i >= 0; i--) {
+    const o = grp.children[i];
+    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(); });
+    }
+    grp.remove(o);
+  }
+}
+
+function _tagColor(tag) {
+  if (tag === "solved") return C_SOLVED;
+  if (tag === "partial") return C_PARTIAL;
+  if (tag === "dead-end") return C_DEAD;
+  return C_INNER;
+}
+
+// Rebuild the full commit tree as a branching DAG from live depth/branch, then
+// overlay the HEAD->root git-log branch in proof-teal. Node count is bounded so
+// the panel stays cheap (cap total rendered nodes).
+function _updateTree() {
+  const THREE = _THREE;
+  if (!_treeGroup) return;
+  _disposeChildren(_treeGroup);
+
+  const live = S.state === "live";
+  if (!live || S.depth == null || S.branch == null) return;
+
+  const depth  = Math.max(1, Math.min(S.depth, 7));
+  const branch = Math.max(1, Math.min(S.branch, 4));
+
+  // cap: don't render more than this many nodes total (keeps big trees legible)
+  const NODE_CAP = 400;
+
+  // place nodes level by level; positions[level] = array of {x,y,idx}
+  const nodeGeo = new THREE.SphereGeometry(NODE_R, 10, 8);
+  const positions = [];
+  let rendered = 0;
+
+  for (let d = 0; d <= depth; d++) {
+    const count = Math.pow(branch, d);
+    const y = 3.0 - d * TREE_DY;                    // root at top, leaves at bottom
+    const levelArr = [];
+    for (let i = 0; i < count; i++) {
+      if (rendered >= NODE_CAP) break;
+      const x = count > 1 ? (-TREE_SPAN / 2 + (TREE_SPAN * i) / (count - 1)) : 0.0;
+      levelArr.push({ x, y, idx: i });
+      rendered++;
+    }
+    positions.push(levelArr);
+  }
+
+  // is a given (depth,idx) node on the HEAD->root git-log branch?
+  // gitLog is HEAD..root (depth descending); reconstruct each level's sibling idx.
+  // For the highlight we approximate the branch as one node per level whose
+  // sibling index matches the recorded git_log slot when derivable; otherwise
+  // fall back to index 0. Robust to shape: we only ever tint, never index-crash.
+  const headBranchIdx = {};   // depth -> idx on the HEAD branch
+  if (Array.isArray(S.gitLog)) {
+    for (const c of S.gitLog) {
+      if (c && typeof c.depth === "number") {
+        // derive sibling index from the content tag "s<idx>" if present
+        let idx = 0;
+        if (typeof c.content === "string") {
+          const mm = c.content.match(/\bs(\d+)\b/);
+          if (mm) idx = parseInt(mm[1], 10);
+        }
+        headBranchIdx[c.depth] = idx;
+      }
+    }
+  }
+
+  // edges (parent links) + nodes
+  const outerTag = { solved: false };
+  for (let d = 0; d <= positions.length - 1; d++) {
+    const level = positions[d];
+    for (let i = 0; i < level.length; i++) {
+      const p = level[i];
+      const isLeaf = d === depth;
+      // colour: leaves by outcome tag (cycled from tag_histogram proportions is
+      // not per-node available, so leaves use score-agnostic solved/partial/dead
+      // by position bucket for a representative palette); inner = grey.
+      let color = C_INNER;
+      if (isLeaf) {
+        // representative tag colouring: split leaves into three bands by index
+        const third = Math.max(1, Math.ceil(level.length / 3));
+        color = i < third ? C_SOLVED : (i < 2 * third ? C_PARTIAL : C_DEAD);
+      }
+      const onHead = (headBranchIdx[d] != null) && (i === Math.min(headBranchIdx[d], level.length - 1));
+      const mat = new THREE.MeshStandardMaterial({
+        color: onHead ? C_HEAD : color,
+        emissive: onHead ? C_HEAD : color,
+        emissiveIntensity: onHead ? 0.6 : 0.25,
+        transparent: true, opacity: onHead ? 0.98 : 0.85,
+      });
+      const mesh = new THREE.Mesh(nodeGeo, mat);
+      mesh.position.set(p.x, p.y, 0);
+      if (onHead) mesh.scale.setScalar(1.6);
+      _treeGroup.add(mesh);
+
+      // edge to parent (parent index = floor(i / branch))
+      if (d > 0) {
+        const parentLevel = positions[d - 1];
+        const pj = Math.floor(i / branch);
+        if (parentLevel[pj]) {
+          const par = parentLevel[pj];
+          const parentOnHead = (headBranchIdx[d - 1] != null) && (pj === Math.min(headBranchIdx[d - 1], parentLevel.length - 1));
+          const edgeHi = onHead && parentOnHead;
+          const eg = new THREE.BufferGeometry().setFromPoints([
+            new THREE.Vector3(par.x, par.y, 0),
+            new THREE.Vector3(p.x, p.y, 0),
+          ]);
+          const em = new THREE.LineBasicMaterial({
+            color: edgeHi ? C_HEAD : C_EDGE,
+            transparent: true,
+            opacity: edgeHi ? 0.9 : 0.35,
+          });
+          _treeGroup.add(new THREE.Line(eg, em));
+        }
+      }
+    }
+  }
+  void outerTag;
+}
+
+// Rebuild the copyability-threshold curve: a 3D line of (similarity, accuracy),
+// a violet-blue vertical plane at the ~0.8 threshold, and a grey baseline line.
+// Points above the threshold are proof-teal, below are lattice-blue — the SHARP
+// jump is visually obvious.
+function _updateCurve() {
+  const THREE = _THREE;
+  if (!_curveGroup) return;
+  _disposeChildren(_curveGroup);
+
+  const live = S.state === "live";
+  if (!live || !Array.isArray(S.sweep) || !S.sweep.length) return;
+
+  const thr = (S.threshold != null) ? S.threshold : 0.8;
+
+  // baseline (no-memory accuracy) grey line across the panel
+  let base = 0.42;
+  if (S.sweep[0] && typeof S.sweep[0].baseline === "number") base = S.sweep[0].baseline;
+  const baseGeo = new THREE.BufferGeometry().setFromPoints([
+    new THREE.Vector3(0, base * CURVE_H, 0),
+    new THREE.Vector3(CURVE_W, base * CURVE_H, 0),
+  ]);
+  _curveGroup.add(new THREE.Line(baseGeo, new THREE.LineBasicMaterial({ color: C_BASE, transparent: true, opacity: 0.5 })));
+
+  // threshold plane at similarity = thr (violet-blue, translucent, vertical)
+  const planeGeo = new THREE.PlaneGeometry(CURVE_H * 1.05, 3.2);
+  const planeMat = new THREE.MeshBasicMaterial({ color: C_THRESH, transparent: true, opacity: 0.12, side: THREE.DoubleSide });
+  const plane = new THREE.Mesh(planeGeo, planeMat);
+  plane.position.set(thr * CURVE_W, CURVE_H * 0.5, 0);
+  plane.rotation.y = Math.PI / 2;
+  _curveGroup.add(plane);
+
+  // accuracy curve — build two coloured segments (below / above threshold)
+  const belowPts = [];
+  const abovePts = [];
+  for (const r of S.sweep) {
+    if (!r || typeof r.similarity !== "number" || typeof r.accuracy !== "number") continue;
+    const v = new THREE.Vector3(r.similarity * CURVE_W, r.accuracy * CURVE_H, 0);
+    if (r.similarity <= thr) belowPts.push(v);
+    if (r.similarity >= thr) abovePts.push(v);
+  }
+  if (belowPts.length >= 2) {
+    const g = new THREE.BufferGeometry().setFromPoints(belowPts);
+    _curveGroup.add(new THREE.Line(g, new THREE.LineBasicMaterial({ color: C_CURVE, transparent: true, opacity: 0.85 })));
+  }
+  if (abovePts.length >= 2) {
+    const g = new THREE.BufferGeometry().setFromPoints(abovePts);
+    _curveGroup.add(new THREE.Line(g, new THREE.LineBasicMaterial({ color: C_CURVEHI, transparent: true, opacity: 0.95 })));
+  }
+
+  // small marker spheres at each sweep point (teal above, blue below)
+  const dotGeo = new THREE.SphereGeometry(0.05, 8, 6);
+  for (const r of S.sweep) {
+    if (!r || typeof r.similarity !== "number" || typeof r.accuracy !== "number") continue;
+    const col = r.similarity >= thr ? C_CURVEHI : C_CURVE;
+    const m = new THREE.Mesh(dotGeo, new THREE.MeshBasicMaterial({ color: col, transparent: true, opacity: 0.9 }));
+    m.position.set(r.similarity * CURVE_W, r.accuracy * CURVE_H, 0);
+    _curveGroup.add(m);
+  }
+}
+
+// diff/merge bars: only-A | shared | only-B commit counts, plus merged count.
+function _updateBars() {
+  const THREE = _THREE;
+  if (!_barGroup) return;
+  _disposeChildren(_barGroup);
+
+  const live = S.state === "live";
+  if (!live) return;
+
+  const geo = new THREE.BoxGeometry(BAR_W, 1.0, BAR_W);
+
+  function bar(x, count, color) {
+    const c = (typeof count === "number") ? count : 0;
+    const h = Math.max(0.06, c * BAR_YSC);
+    const mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({
+      color, emissive: color, emissiveIntensity: 0.4, transparent: true, opacity: 0.92,
+    }));
+    mesh.scale.y = h;
+    mesh.position.set(x, h * 0.5, 0);
+    _barGroup.add(mesh);
+  }
+
+  const d = S.diff || {};
+  bar(0.0, d.only_a_count, C_ONLYA);
+  bar(1.0, d.shared_count, C_SHARED);
+  bar(2.0, d.only_b_count, C_ONLYB);
+  const m = S.merge || {};
+  bar(3.3, m.merged_commit_count, C_MERGE);
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.10;
+}
+
+// =============================================================================
+// 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%,480px)",
+    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 =
+    'GitOfThoughts stores an agent\u2019s reasoning tree as a <b>git repository</b>: every scored thought is a ' +
+    '<b>commit</b> (sha256 over parent+content+score \u2014 a Merkle DAG), scores are <b>notes</b>, outcomes are ' +
+    '<b>tags</b>, and retrieval is a <b>git log</b> DAG walk. This organ models the substrate \u2014 <b>log, replay, ' +
+    'diff, merge</b> \u2014 and the paper\u2019s honest <b>copyability threshold</b>: memory only helps once the ' +
+    'retrieved case is a near-duplicate (cosine similarity above <b>~0.8</b>); below it there is <b>no gain</b> ' +
+    '(the model finds the answer, it does not transfer the method). Panels: commit tree, threshold curve, ' +
+    'diff/merge bars. Honesty label <b>MODELED</b> (data-structure + finding reproduction; runs no LLM). 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 = "gitofthoughts version-controlled reasoning";
+  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("gt-tree",    "reasoning tree (depth \u00d7 branch)"));
+  grid.appendChild(kpiRow("gt-commits", "commits (thoughts)"));
+  grid.appendChild(kpiRow("gt-leaves",  "terminal thoughts (tagged)"));
+  grid.appendChild(kpiRow("gt-head",    "HEAD sha (highest-scoring leaf)"));
+  grid.appendChild(kpiRow("gt-log",     "git log length (HEAD\u2192root)"));
+  grid.appendChild(kpiRow("gt-replay",  "replay verified (shas re-derived)"));
+  grid.appendChild(kpiRow("gt-diff",    "diff (onlyA / shared / onlyB)"));
+  grid.appendChild(kpiRow("gt-merge",   "merge (commits / conflicts)"));
+  grid.appendChild(kpiRow("gt-tags",    "outcomes (solved / partial / dead)"));
+  grid.appendChild(kpiRow("gt-thr",     "copyability threshold (cosine)"));
+  grid.appendChild(kpiRow("gt-jump",    "accuracy jump across threshold"));
+  grid.appendChild(kpiRow("gt-below",   "gain BELOW threshold (MEASURED)"));
+  grid.appendChild(kpiRow("gt-above",   "gain ABOVE threshold (MEASURED)"));
+  grid.appendChild(kpiRow("gt-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 = "GitOfThoughts \u2014 Shekar, Abhishek H S, Krishnan, arXiv:2606.14470 (arxiv.org/abs/2606.14470) \u00b7 git object model, Pro Git. MODELED \u00b7 data-structure + copyability-threshold reproduction; runs no LLM; memory does NOT improve novel-problem accuracy (reproduced honestly).";
+  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 = "gt-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 thr   = S.threshold != null ? S.threshold.toFixed(2)   : "~0.80";
+  const jump  = S.jumpSize   != null ? (S.jumpSize * 100).toFixed(0) + " pts" : "loading\u2026";
+  const below = S.gainBelow  != null ? (S.gainBelow * 100).toFixed(1) + "%"   : "loading\u2026";
+  const comm  = S.commitCount != null ? String(S.commitCount) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> When an AI reasons, its train of thought vanishes the moment it finishes \u2014 you " +
+    "cannot audit it, replay it, or combine two agents\u2019 histories. GitOfThoughts fixes that by saving every " +
+    "thought as a <b>git commit</b>, exactly like version-controlling code: each thought gets a fingerprint " +
+    "(sha) built from its parent and content, so the whole history is tamper-evident and you can <b>replay, " +
+    "diff, and merge</b> it. Here the tree holds about <b>" + comm + "</b> commits. But the researchers asked a " +
+    "blunt question \u2014 <i>does giving an agent this memory make it smarter on new problems?</i> \u2014 and their " +
+    "honest answer was <b>no</b>. Memory only helps when a past case is almost identical to the new one " +
+    "(similarity above <b>" + thr + "</b>): then the model is simply <b>copying the answer</b>, not learning the " +
+    "method. Below that line, the gain is essentially zero (<b>" + below + "</b> here). This view reproduces both the " +
+    "data structure AND that honesty: the accuracy curve is flat until it <b>jumps by ~" + jump + "</b> right at the " +
+    "threshold. This is a <b>MODELED</b> demo \u2014 it runs no real AI and claims no accuracy improvement. The value of " +
+    "git-as-memory is <b>auditability and mergeability</b>, not smarter answers.";
+}
+
+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("gt-tree",    t || ((S.depth != null && S.branch != null) ? (S.depth + " \u00d7 " + S.branch) : "\u2014"));
+  _set("gt-commits", t || (S.commitCount != null ? String(S.commitCount) : "\u2014"));
+  _set("gt-leaves",  t || (S.leafCount != null ? String(S.leafCount) : "\u2014"));
+  _set("gt-head",    t || (S.headSha ? String(S.headSha).slice(0, 7) : "\u2014"));
+  _set("gt-log",     t || ((Array.isArray(S.gitLog)) ? String(S.gitLog.length) : "\u2014"));
+  _set("gt-replay",  t || (S.replayOk == null ? "\u2014" : (S.replayOk ? ("OK (" + (S.replayLen != null ? S.replayLen : "?") + " commits)") : "MISMATCH")));
+  _set("gt-diff",    t || (S.diff ? (fx0(S.diff.only_a_count) + " / " + fx0(S.diff.shared_count) + " / " + fx0(S.diff.only_b_count)) : "\u2014"));
+  _set("gt-merge",   t || (S.merge ? (fx0(S.merge.merged_commit_count) + " / " + fx0(S.merge.conflict_count)) : "\u2014"));
+  _set("gt-tags",    t || (S.tagHist ? (fx0(S.tagHist.solved) + " / " + fx0(S.tagHist.partial) + " / " + fx0(S.tagHist["dead-end"])) : "\u2014"));
+  _set("gt-thr",     t || (S.threshold != null ? "\u2248 " + fx(S.threshold, 2) : "\u2014"));
+  _set("gt-jump",    t || (S.jumpSize != null ? "+" + (S.jumpSize * 100).toFixed(1) + " pts" : "\u2014"));
+  _set("gt-below",   t || pct(S.gainBelow, 1));
+  _set("gt-above",   t || pct(S.gainAbove, 1));
+  // honesty label verbatim — never upgraded
+  _set("gt-label",   t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+function fx0(v) { return typeof v === "number" ? String(v) : "\u2014"; }
+
+// =============================================================================
+// 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;
+  _treeGroup = null;
+  _curveGroup = null;
+  _barGroup = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.depth = S.branch = S.commitCount = S.leafCount = null;
+  S.headSha = S.rootSha = null;
+  S.gitLog = null; S.replayOk = null; S.replayLen = null;
+  S.diff = S.merge = S.tagHist = null;
+  S.threshold = S.sweep = S.jumpSize = S.gainBelow = S.gainAbove = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/herotq.js

@@ -0,0 +1,567 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/herotq.js — HeRo-Q HESSIAN-CONDITIONED LOW-BIT QUANTIZATION organ for
+// the holographic frontier ring (HeRo-Q = "Hessian Robust Quantization"; Zhang,
+// Jinhao et al., arXiv:2601.21626). Renders the rotation-compression transform
+// that REDUCES THE LARGEST HESSIAN EIGENVALUE before low-bit quantizing, as
+// three live panels:
+//   (1) HESSIAN SPECTRUM — one bar per eigenvalue of the loss-landscape Hessian,
+//       shown BEFORE (raw λ, a few tall stiff directions) vs AFTER the HeRo-Q
+//       rotation-compression (transformed λ/s², flattened) — the eigenvalue
+//       reduction that reshapes the loss landscape;
+//   (2) WEIGHT RECONSTRUCTION — the toy weight vector w drawn as a 3D line,
+//       overlaid with its NAIVE `bits`-bit quantized reconstruction and its
+//       HeRo-Q reconstruction, so the two rounding paths are visible;
+//   (3) METRIC BARS — quant MSE (naive vs HeRo-Q) and curvature-weighted
+//       loss-proxy ½·Δwᵀ H Δw (naive vs HeRo-Q), honestly showing the paper's
+//       "low error, high loss" paradox: naive has LOWER error but HIGHER loss.
+// A HUD reports the MEASURED metrics from the live snapshot at
+// /api/killinchu/v1/herotq/quantize. Honesty label "MODELED" is read VERBATIM
+// from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors muon.js / ternary.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   size, bits, levels, hessian_eigs[...], max_hessian_eig_before,
+//   max_hessian_eig_after, eig_reduction_factor, cond_before, cond_after,
+//   quant_mse_naive, quant_mse_herotq, loss_proxy_naive, loss_proxy_herotq,
+//   loss_reduction_factor, low_error_high_loss, weight_raw[...],
+//   weight_naive_q[...], weight_herotq_q[...]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   HeRo-Q: A General Framework for Stable Low Bit Quantization via Hessian
+//     Conditioning — Zhang, Jinhao et al. arXiv:2601.21626
+//     https://arxiv.org/abs/2601.21626
+//
+// HONESTY LABELS: MODELED (deterministic reproduction of the HeRo-Q Hessian-
+//   conditioning ROTATION-COMPRESSION mechanism on a toy synthetic weight vector
+//   + synthetic Hessian; NOT a trained model; quantizes nothing real; the
+//   eigenvalue reduction and curvature-weighted loss drop are MEASURED and
+//   displayed; NEVER-CLAIMED-AS reproducing the GSM8K/Llama3-8B numbers). Read
+//   verbatim from JSON.
+// DISTINCTNESS: this is the HESSIAN-EIGENVALUE rotation-compression mechanism —
+//   NOT ternary (2-bit sign) weights and NOT FP4 block-scaling / codebook
+//   quantization. The distinguishing object is the Hessian eigenvalue spectrum.
+// COLOURS: lattice-blue 0x5b8dee, violet-blue 0x8a6bff, proof-teal 0x3af4c8,
+//   greys (0x5a6570 / 0x42505d). 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    = "herotq";
+const TITLE = "HeRo-Q Hessian-Conditioned Quantization";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute),
+// reached cross-origin (killinchu returns access-control-allow-origin).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/herotq/quantize?seed=42&size=32&bits=3";
+
+// data-viz hues — purple BANNED
+const C_BEFORE = 0x5b8dee;  // lattice-blue (raw Hessian spectrum / raw weight)
+const C_AFTER  = 0x3af4c8;  // proof-teal   (transformed spectrum / HeRo-Q recon)
+const C_NAIVE  = 0x8a6bff;  // violet-blue  (naive quantized reconstruction / naive bar)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_ZERO   = 0x5a6570;  // grey (near-zero / axis)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const SPEC_X0   = -6.0;   // spectrum panel origin x
+const SPEC_DX   = 0.34;   // world-units per eigenvalue bar
+const SPEC_YSC  = 0.16;   // world-units per unit eigenvalue (log-ish handled in code)
+const SPEC_BW   = 0.14;   // spectrum bar footprint
+const W_X0      = -3.2;   // weight-line panel origin x
+const W_DX      = 0.22;   // world-units per weight coordinate
+const W_YSC     = 2.2;    // world-units per unit weight value
+const BAR_W     = 0.7;    // metric bar width
+
+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 _specGroup  = null;   // THREE.Group — Hessian eigenvalue bars (before/after)
+let _specBefore = [];     // Array<THREE.Mesh> — raw-λ bars
+let _specAfter  = [];     // Array<THREE.Mesh> — transformed-λ bars
+let _wGroup     = null;   // THREE.Group — weight reconstruction lines
+let _barGroup   = null;   // THREE.Group — metric bars
+let _barMseN    = null;   // naive MSE bar
+let _barMseH    = null;   // HeRo-Q MSE bar
+let _barLossN   = null;   // naive loss-proxy bar
+let _barLossH   = null;   // HeRo-Q loss-proxy bar
+
+// live state
+const S = {
+  label:       null,
+  size:        null,
+  bits:        null,
+  levels:      null,
+  eigs:        null,   // hessian_eigs
+  maxBefore:   null,   // max_hessian_eig_before
+  maxAfter:    null,   // max_hessian_eig_after
+  eigRed:      null,   // eig_reduction_factor
+  condBefore:  null,   // cond_before
+  condAfter:   null,   // cond_after
+  mseNaive:    null,   // quant_mse_naive
+  mseHerotq:   null,   // quant_mse_herotq
+  lossNaive:   null,   // loss_proxy_naive
+  lossHerotq:  null,   // loss_proxy_herotq
+  lossRed:     null,   // loss_reduction_factor
+  paradox:     null,   // low_error_high_loss
+  wRaw:        null,   // weight_raw
+  wNaive:      null,   // weight_naive_q
+  wHerotq:     null,   // weight_herotq_q
+  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(2, 7, 18);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 1.5, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildSpectrum();
+  _buildWeights();
+  _buildBars();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onHerotq, { badge: _badge, onState: (msg) => { S.state = msg.state; _updateAll(); _paintOverlay(); } }));
+
+  _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);
+  _floor = grid;
+}
+
+// Hessian spectrum panel: two rows of bars — raw λ (before, lattice-blue) at the
+// back, transformed λ/s² (after, proof-teal) in front. Pre-allocate a fixed cap
+// and toggle visibility/height in place (no churn).
+const SPEC_MAX = 64;
+function _buildSpectrum() {
+  const THREE = _THREE;
+  _specGroup = new THREE.Group();
+  _specGroup.position.set(SPEC_X0, 0, -2.6);
+  _group.add(_specGroup);
+  const geo = new THREE.BoxGeometry(SPEC_BW, 1.0, SPEC_BW);
+
+  function makeRow(zoff, color, arr) {
+    for (let i = 0; i < SPEC_MAX; i++) {
+      const mesh = new THREE.Mesh(
+        geo,
+        new THREE.MeshStandardMaterial({ color, emissive: color, emissiveIntensity: 0.32, transparent: true, opacity: 0.9 }),
+      );
+      mesh.position.set(i * SPEC_DX, 0.02, zoff);
+      mesh.scale.y = 0.02;
+      mesh.visible = false;
+      _specGroup.add(mesh);
+      arr.push(mesh);
+    }
+  }
+  makeRow(0.0, C_BEFORE, _specBefore);
+  makeRow(0.9, C_AFTER,  _specAfter);
+}
+
+// weight reconstruction panel: three polylines rebuilt in place on fresh data.
+function _buildWeights() {
+  const THREE = _THREE;
+  _wGroup = new THREE.Group();
+  _wGroup.position.set(W_X0, 1.4, 3.0);
+  _group.add(_wGroup);
+  // lines are added by _updateWeights once data arrives
+}
+
+function _buildBars() {
+  const THREE = _THREE;
+  _barGroup = new THREE.Group();
+  _barGroup.position.set(5.4, 0, 0.4);
+  _group.add(_barGroup);
+  const geo = new THREE.BoxGeometry(BAR_W, 1.0, BAR_W);
+
+  function mk(x, color) {
+    const m = new THREE.Mesh(
+      geo,
+      new THREE.MeshStandardMaterial({ color, emissive: color, emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+    );
+    m.position.set(x, 0.02, 0);
+    m.scale.y = 0.02;
+    _barGroup.add(m);
+    return m;
+  }
+  // MSE pair (front row), loss pair (back row)
+  _barMseN  = mk(0.0,  C_NAIVE);
+  _barMseH  = mk(0.95, C_AFTER);
+  _barLossN = mk(0.0,  C_NAIVE); _barLossN.position.z = 1.6;
+  _barLossH = mk(0.95, C_AFTER); _barLossH.position.z = 1.6;
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onHerotq(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.size       = typeof src.size                   === "number" ? src.size                   : null;
+  S.bits       = typeof src.bits                   === "number" ? src.bits                   : null;
+  S.levels     = typeof src.levels                 === "number" ? src.levels                 : null;
+  S.maxBefore  = typeof src.max_hessian_eig_before === "number" ? src.max_hessian_eig_before : null;
+  S.maxAfter   = typeof src.max_hessian_eig_after  === "number" ? src.max_hessian_eig_after  : null;
+  S.eigRed     = typeof src.eig_reduction_factor   === "number" ? src.eig_reduction_factor   : null;
+  S.condBefore = typeof src.cond_before            === "number" ? src.cond_before            : null;
+  S.condAfter  = typeof src.cond_after             === "number" ? src.cond_after             : null;
+  S.mseNaive   = typeof src.quant_mse_naive        === "number" ? src.quant_mse_naive        : null;
+  S.mseHerotq  = typeof src.quant_mse_herotq       === "number" ? src.quant_mse_herotq       : null;
+  S.lossNaive  = typeof src.loss_proxy_naive       === "number" ? src.loss_proxy_naive       : null;
+  S.lossHerotq = typeof src.loss_proxy_herotq      === "number" ? src.loss_proxy_herotq      : null;
+  S.lossRed    = typeof src.loss_reduction_factor  === "number" ? src.loss_reduction_factor  : null;
+  S.paradox    = typeof src.low_error_high_loss    === "boolean" ? src.low_error_high_loss   : null;
+
+  S.eigs    = Array.isArray(src.hessian_eigs)   ? src.hessian_eigs   : null;
+  S.wRaw    = Array.isArray(src.weight_raw)     ? src.weight_raw     : null;
+  S.wNaive  = Array.isArray(src.weight_naive_q) ? src.weight_naive_q : null;
+  S.wHerotq = Array.isArray(src.weight_herotq_q)? src.weight_herotq_q: null;
+
+  _updateAll();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updaters
+// =============================================================================
+function _updateAll() {
+  _updateSpectrum();
+  _updateWeights();
+  _updateBars();
+}
+
+// height ∝ log10(1+λ) so tall stiff directions and flat ones are both legible.
+function _lh(v) { return Math.max(0.03, Math.log10(1.0 + Math.max(0.0, v)) * 3.0); }
+
+function _updateSpectrum() {
+  const live = S.state === "live";
+  const eigs = (live && S.eigs) ? S.eigs : null;
+  // "after" spectrum is reconstructed geometrically: the flattened spectrum has
+  // the same count but is capped at max_hessian_eig_after (the measured λ_max
+  // the grid must resolve); we scale each raw λ toward that ceiling so the
+  // visual monotonically maps the measured reduction without fabricating values.
+  const n = eigs ? Math.min(eigs.length, SPEC_MAX) : 0;
+  const capAfter = (S.maxAfter != null) ? S.maxAfter : 0.0;
+  const maxRaw = (eigs && eigs.length) ? Math.max.apply(null, eigs) : 1.0;
+
+  for (let i = 0; i < SPEC_MAX; i++) {
+    const b = _specBefore[i], a = _specAfter[i];
+    if (!live || i >= n) {
+      if (b) { b.visible = false; }
+      if (a) { a.visible = false; }
+      continue;
+    }
+    const lam = eigs[i];
+    // before bar
+    b.visible = true;
+    let hb = _lh(lam);
+    b.scale.y = hb; b.position.y = hb * 0.5;
+    b.material.color.setHex(C_BEFORE); b.material.emissive.setHex(C_BEFORE);
+    b.material.opacity = 0.9;
+    // after bar: transformed curvature the grid resolves is bounded by capAfter.
+    // map λ proportionally into [0, capAfter] so stiff directions collapse.
+    a.visible = true;
+    const lamAfter = maxRaw > 0 ? (lam / maxRaw) * capAfter : 0.0;
+    let ha = _lh(lamAfter);
+    a.scale.y = ha; a.position.y = ha * 0.5;
+    a.material.color.setHex(C_AFTER); a.material.emissive.setHex(C_AFTER);
+    a.material.opacity = 0.9;
+  }
+}
+
+// rebuild the three weight polylines (raw / naive / HeRo-Q) from live data.
+function _updateWeights() {
+  const THREE = _THREE;
+  if (!_wGroup) return;
+  // dispose previous children
+  for (let i = _wGroup.children.length - 1; i >= 0; i--) {
+    const o = _wGroup.children[i];
+    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(); });
+    }
+    _wGroup.remove(o);
+  }
+  const live = S.state === "live";
+  if (!live) return;
+
+  function addLine(arr, color, op) {
+    if (!Array.isArray(arr) || !arr.length) return;
+    const pts = [];
+    for (let i = 0; i < arr.length; i++) {
+      const v = typeof arr[i] === "number" ? arr[i] : 0.0;
+      pts.push(new THREE.Vector3(i * W_DX, v * W_YSC, 0));
+    }
+    const lg = new THREE.BufferGeometry().setFromPoints(pts);
+    const lm = new THREE.LineBasicMaterial({ color, transparent: true, opacity: op });
+    _wGroup.add(new THREE.Line(lg, lm));
+  }
+  addLine(S.wRaw,    C_BEFORE, 0.85);
+  addLine(S.wNaive,  C_NAIVE,  0.7);
+  addLine(S.wHerotq, C_AFTER,  0.9);
+}
+
+// metric bars: MSE pair + loss-proxy pair. height on independent normalizers so
+// each pair is legible; the honest STORY is naive-MSE lower, naive-loss higher.
+function _updateBars() {
+  const live = S.state === "live";
+  function setBar(mesh, val, refMax, color) {
+    if (!mesh) return;
+    if (!live || val == null) {
+      mesh.material.color.setHex(C_DIM);
+      mesh.material.emissive.setHex(C_DIM);
+      mesh.material.opacity = 0.3;
+      mesh.scale.y = 0.02; mesh.position.y = 0.01;
+      return;
+    }
+    const denom = refMax > 1e-12 ? refMax : 1.0;
+    const h = Math.max(0.05, (val / denom) * 3.4);
+    mesh.scale.y = h; mesh.position.y = h * 0.5;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = 0.4;
+    mesh.material.opacity = 0.92;
+  }
+  const mseMax = Math.max(S.mseNaive || 0, S.mseHerotq || 0);
+  const lossMax = Math.max(S.lossNaive || 0, S.lossHerotq || 0);
+  setBar(_barMseN,  S.mseNaive,   mseMax,  C_NAIVE);
+  setBar(_barMseH,  S.mseHerotq,  mseMax,  C_AFTER);
+  setBar(_barLossN, S.lossNaive,  lossMax, C_NAIVE);
+  setBar(_barLossH, S.lossHerotq, lossMax, C_AFTER);
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.12;
+}
+
+// =============================================================================
+// 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 =
+    'HeRo-Q (\u201cHessian Robust Quantization\u201d) fixes the <b>\u201clow error, high loss\u201d</b> paradox in ' +
+    'low-bit quantization: naive rounding minimizes weight ERROR, but the loss actually depends on the ' +
+    '<b>Hessian</b> \u2014 a few <b>high-curvature directions</b> (large eigenvalues) are extremely ' +
+    'perturbation-sensitive. HeRo-Q applies a <b>rotation-compression</b> transform in the Hessian ' +
+    'eigenbasis (w<sub>q</sub> = V(s<sup>\u22121</sup>\u2299q(s\u2299V\u1d40w)), s<sub>i</sub>=\u221a(1+\u03bb<sub>i</sub>/\u03bb<sub>med</sub>)) that ' +
+    '<b>reduces the largest Hessian eigenvalue</b> before quantizing. Panels: Hessian spectrum ' +
+    '(before vs after), weight reconstruction (raw / naive / HeRo-Q), metric bars (quant MSE & ' +
+    'curvature-weighted loss ½\u00b7\u0394w\u1d40H\u0394w). Honesty label <b>MODELED</b> (deterministic mechanism ' +
+    'reproduction on a toy matrix; quantizes nothing real). 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 = "hero-q hessian-conditioned quantization";
+  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("hq-size",  "weight / Hessian size"));
+  grid.appendChild(kpiRow("hq-bits",  "quantization bits (levels)"));
+  grid.appendChild(kpiRow("hq-eigb",  "max Hessian \u03bb \u2014 BEFORE"));
+  grid.appendChild(kpiRow("hq-eiga",  "max Hessian \u03bb \u2014 AFTER"));
+  grid.appendChild(kpiRow("hq-eigr",  "eigenvalue reduction"));
+  grid.appendChild(kpiRow("hq-cond",  "condition \u03ba (before \u2192 after)"));
+  grid.appendChild(kpiRow("hq-msen",  "quant MSE \u2014 naive"));
+  grid.appendChild(kpiRow("hq-mseh",  "quant MSE \u2014 HeRo-Q"));
+  grid.appendChild(kpiRow("hq-lossn", "loss-proxy \u00bd\u0394w\u1d40H\u0394w \u2014 naive"));
+  grid.appendChild(kpiRow("hq-lossh", "loss-proxy \u00bd\u0394w\u1d40H\u0394w \u2014 HeRo-Q"));
+  grid.appendChild(kpiRow("hq-lossr", "loss reduction"));
+  grid.appendChild(kpiRow("hq-para",  "\u201clow error, high loss\u201d (naive)"));
+  grid.appendChild(kpiRow("hq-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 = "HeRo-Q \u2014 Zhang, Jinhao et al. \u201cHeRo-Q: A General Framework for Stable Low Bit Quantization via Hessian Conditioning\u201d arXiv:2601.21626. MODELED \u00b7 Hessian-conditioning demo on a toy matrix, not a trained model. Does NOT reproduce the GSM8K/Llama3-8B numbers.";
+  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 = "hq-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 eb  = S.maxBefore != null ? S.maxBefore.toFixed(1) : "loading\u2026";
+  const ea  = S.maxAfter  != null ? S.maxAfter.toFixed(2)  : "loading\u2026";
+  const er  = S.eigRed    != null ? S.eigRed.toFixed(1) + "\u00d7" : "loading\u2026";
+  const lr  = S.lossRed   != null ? S.lossRed.toFixed(1) + "\u00d7" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> To make a big model small and fast, we store its numbers with very few " +
+    "bits \u2014 like rounding prices to the nearest dollar. Plain rounding keeps the <b>numbers</b> close, " +
+    "but the model can still get much <b>worse</b>, because a few \u201cstiff\u201d directions matter far more " +
+    "than the rest (the \u201clow error, high loss\u201d paradox). HeRo-Q first <b>turns and rescales</b> the " +
+    "weights so those stiff directions get more of the rounding precision \u2014 like giving the most " +
+    "fragile items the most padding before shipping. Here the biggest \u201cstiffness\u201d (largest Hessian " +
+    "eigenvalue) drops from about <b>" + eb + "</b> to about <b>" + ea + "</b> \u2014 a <b>" + er + "</b> " +
+    "flattening \u2014 and the curvature-weighted error (the thing that actually hurts the model) falls by " +
+    "about <b>" + lr + "</b>, even though the raw rounding error is slightly larger. This view is a " +
+    "<b>MODELED</b> deterministic reproduction of that turn-and-rescale MECHANISM on a small synthetic " +
+    "matrix \u2014 it <b>quantizes no real model</b> and runs no benchmark. The paper\u2019s headline " +
+    "\u201c70.15% GSM8K on Llama3-8B at 3-bit\u201d is a <b>claim about a real model</b> the estate does not " +
+    "independently verify.";
+}
+
+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("hq-size",  t || (S.size != null ? String(S.size) : "\u2014"));
+  _set("hq-bits",  t || ((S.bits != null && S.levels != null) ? (S.bits + "-bit (" + S.levels + " levels)") : "\u2014"));
+  _set("hq-eigb",  t || fx(S.maxBefore, 3));
+  _set("hq-eiga",  t || fx(S.maxAfter, 3));
+  _set("hq-eigr",  t || (S.eigRed != null ? S.eigRed.toFixed(1) + "\u00d7" : "\u2014"));
+  _set("hq-cond",  t || ((S.condBefore != null && S.condAfter != null) ? (fx(S.condBefore, 1) + " \u2192 " + fx(S.condAfter, 2)) : "\u2014"));
+  _set("hq-msen",  t || fx(S.mseNaive, 5));
+  _set("hq-mseh",  t || fx(S.mseHerotq, 5));
+  _set("hq-lossn", t || fx(S.lossNaive, 4));
+  _set("hq-lossh", t || fx(S.lossHerotq, 4));
+  _set("hq-lossr", t || (S.lossRed != null ? S.lossRed.toFixed(1) + "\u00d7" : "\u2014"));
+  _set("hq-para",  t || (S.paradox != null ? (S.paradox ? "PRESENT \u2192 fixed" : "\u2014") : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("hq-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;
+  _specGroup = null; _specBefore = []; _specAfter = [];
+  _wGroup = null;
+  _barGroup = null; _barMseN = _barMseH = _barLossN = _barLossH = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.size = S.bits = S.levels = null;
+  S.eigs = null;
+  S.maxBefore = S.maxAfter = S.eigRed = S.condBefore = S.condAfter = null;
+  S.mseNaive = S.mseHerotq = S.lossNaive = S.lossHerotq = S.lossRed = null;
+  S.paradox = null;
+  S.wRaw = S.wNaive = S.wHerotq = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/keyless.js

@@ -0,0 +1,506 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/keyless.js — KEYLESS ATTENTION (VALUE-ONLY CACHE) organ for the
+// holographic frontier ring (Xin Gao, arXiv:2606.21848). Renders the
+// value-only-cache mechanism vs standard QKV attention as three live panels:
+//   (1) CACHE-SIZE BARS — standard cache (K+V = 2·L·d) vs keyless cache
+//       (V-only = L·d), the exact 50% shrink shown as two boxes;
+//   (2) ATTENTION-MAP HEATMAPS — the standard softmax(Q·Kᵀ/√d) map vs the
+//       keyless softmax((Q·R)·Vᵀ/√d) map, as two grids of coloured cells;
+//   (3) OUTPUT-FIDELITY BAR — mean per-token cosine similarity between the two
+//       attention outputs, the MEASURED "matches within X on the toy" metric.
+// A HUD reports the MEASURED metrics from the live snapshot at
+// /api/killinchu/v1/keyless/attention. Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors muon.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   L, d, m, bytes_per_entry, kv_entries_standard, kv_entries_keyless,
+//   kv_bytes_standard, kv_bytes_keyless, reduction_pct, cosine_mean,
+//   cosine_min, mse, scores_std_head[[...]], scores_keyless_head[[...]]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFIED real):
+//   Keyless Attention: Value-Space Routing and Value-Only Caching for Efficient
+//     Transformers — Xin Gao. arXiv:2606.21848
+//     https://arxiv.org/abs/2606.21848
+//
+// HONESTY LABELS: MODELED (deterministic reproduction of the value-only-cache +
+//   value-space-routing MECHANISM on a toy synthetic sequence; NOT a trained
+//   transformer; trains nothing; the 50% cache shrink is exact arithmetic and
+//   the output fidelity is MEASURED; NEVER-CLAIMED-AS a production kernel).
+//   Read verbatim from JSON.
+// COLOURS: lattice-blue 0x5b8dee, violet-blue 0x8a6bff, proof-teal 0x3af4c8,
+//   greys (0x5a6570 / 0x42505d). 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    = "keyless";
+const TITLE = "Keyless Attention (Value-Only Cache)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute),
+// reached cross-origin (killinchu returns access-control-allow-origin).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/keyless/attention?seed=42&L=16&d=16&m=3";
+
+// data-viz hues — purple BANNED
+const C_STD      = 0x5b8dee;  // lattice-blue (standard cache bar / std heatmap)
+const C_KEYLESS  = 0x3af4c8;  // proof-teal   (keyless cache bar / keyless heatmap)
+const C_FID      = 0x8a6bff;  // violet-blue  (output-fidelity bar)
+const C_DIM      = 0x42505d;  // grey (degraded / no-live-data)
+const C_ZERO     = 0x5a6570;  // grey (near-zero heatmap cell)
+const C_GRID     = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const HEAT_CELL  = 0.16;   // heatmap cell size
+const HEAT_GAP   = 0.17;   // heatmap cell pitch
+const HEAT_MAX   = 8;      // cap cells per axis rendered (matches head trim)
+const BAR_W      = 0.9;    // cache-bar width
+
+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 _heatStd    = [];     // Array<THREE.Mesh> — standard attention-map cells
+let _heatKeyless= [];     // Array<THREE.Mesh> — keyless attention-map cells
+let _heatGroup  = null;
+let _barStd     = null;   // THREE.Mesh — standard cache-size bar (K+V)
+let _barKeyless = null;   // THREE.Mesh — keyless cache-size bar (V-only)
+let _barFid     = null;   // THREE.Mesh — output-fidelity (cosine) bar
+let _barGroup   = null;
+
+// live state
+const S = {
+  label:      null,
+  L:          null,
+  d:          null,
+  m:          null,
+  bytesPer:   null,   // bytes_per_entry
+  kvEntStd:   null,   // kv_entries_standard
+  kvEntKey:   null,   // kv_entries_keyless
+  kvBytesStd: null,   // kv_bytes_standard
+  kvBytesKey: null,   // kv_bytes_keyless
+  reduction:  null,   // reduction_pct
+  cosMean:    null,   // cosine_mean
+  cosMin:     null,   // cosine_min
+  mse:        null,
+  scoresStd:  null,   // Array<Array<number>>
+  scoresKey:  null,   // Array<Array<number>>
+  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(5, 6, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(2, 1.5, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildHeatmaps();
+  _buildBars();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onKeyless, { badge: _badge, onState: (msg) => { S.state = msg.state; _updateAll(); _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 grids of coloured cells (standard | keyless attention maps). Pre-allocate
+// a fixed HEAT_MAX x HEAT_MAX per side; toggle visibility/color in place.
+function _buildHeatmaps() {
+  const THREE = _THREE;
+  _heatGroup = new THREE.Group();
+  _heatGroup.position.set(0.0, 0.05, 2.6);
+  _group.add(_heatGroup);
+  const cellGeo = new THREE.PlaneGeometry(HEAT_CELL, HEAT_CELL);
+
+  function makeGrid(offsetX, arr) {
+    for (let r = 0; r < HEAT_MAX; r++) {
+      for (let c = 0; c < HEAT_MAX; c++) {
+        const mesh = new THREE.Mesh(
+          cellGeo,
+          new THREE.MeshBasicMaterial({ color: C_ZERO, transparent: true, opacity: 0.0, side: THREE.DoubleSide }),
+        );
+        mesh.rotation.x = -Math.PI / 2;
+        mesh.position.set(offsetX + c * HEAT_GAP, 0.02, r * HEAT_GAP);
+        mesh.visible = false;
+        _heatGroup.add(mesh);
+        arr.push(mesh);
+      }
+    }
+  }
+  makeGrid(0.0, _heatStd);
+  makeGrid(HEAT_MAX * HEAT_GAP + 0.8, _heatKeyless);
+}
+
+function _buildBars() {
+  const THREE = _THREE;
+  _barGroup = new THREE.Group();
+  _barGroup.position.set(-3.4, 0, 0.0);
+  _group.add(_barGroup);
+  const geo = new THREE.BoxGeometry(BAR_W, 1.0, BAR_W);
+
+  _barStd = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_STD, emissive: C_STD, emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+  );
+  _barStd.position.set(0, 0.5, 0);
+  _barGroup.add(_barStd);
+
+  _barKeyless = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_KEYLESS, emissive: C_KEYLESS, emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+  );
+  _barKeyless.position.set(1.3, 0.5, 0);
+  _barGroup.add(_barKeyless);
+
+  _barFid = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_FID, emissive: C_FID, emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+  );
+  _barFid.position.set(2.6, 0.5, 0);
+  _barGroup.add(_barFid);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onKeyless(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.L          = typeof src.L                   === "number" ? src.L                   : null;
+  S.d          = typeof src.d                   === "number" ? src.d                   : null;
+  S.m          = typeof src.m                   === "number" ? src.m                   : null;
+  S.bytesPer   = typeof src.bytes_per_entry     === "number" ? src.bytes_per_entry     : null;
+  S.kvEntStd   = typeof src.kv_entries_standard === "number" ? src.kv_entries_standard : null;
+  S.kvEntKey   = typeof src.kv_entries_keyless  === "number" ? src.kv_entries_keyless  : null;
+  S.kvBytesStd = typeof src.kv_bytes_standard   === "number" ? src.kv_bytes_standard   : null;
+  S.kvBytesKey = typeof src.kv_bytes_keyless    === "number" ? src.kv_bytes_keyless    : null;
+  S.reduction  = typeof src.reduction_pct       === "number" ? src.reduction_pct       : null;
+  S.cosMean    = typeof src.cosine_mean         === "number" ? src.cosine_mean         : null;
+  S.cosMin     = typeof src.cosine_min          === "number" ? src.cosine_min          : null;
+  S.mse        = typeof src.mse                 === "number" ? src.mse                 : null;
+
+  S.scoresStd  = Array.isArray(src.scores_std_head)     ? src.scores_std_head     : null;
+  S.scoresKey  = Array.isArray(src.scores_keyless_head) ? src.scores_keyless_head : null;
+
+  _updateAll();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updaters
+// =============================================================================
+function _updateAll() {
+  _updateHeatmaps();
+  _updateBars();
+}
+
+// colour a heatmap grid from an attention map: base hue, |value| -> opacity.
+// Near-zero -> grey.
+function _paintHeat(arr, mat, baseColor) {
+  const live = S.state === "live";
+  const rows = (live && mat && mat.length) ? Math.min(mat.length, HEAT_MAX) : 0;
+  const cols = (live && mat && mat[0]) ? Math.min(mat[0].length, HEAT_MAX) : 0;
+
+  // find max for normalization (attention weights are in [0,1])
+  let amax = 0.0;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const v = Math.abs(mat[r][c]);
+      if (v > amax) amax = v;
+    }
+  }
+  if (amax <= 0.0) amax = 1.0;
+
+  for (let r = 0; r < HEAT_MAX; r++) {
+    for (let c = 0; c < HEAT_MAX; c++) {
+      const mesh = arr[r * HEAT_MAX + c];
+      if (!live || r >= rows || c >= cols) { mesh.visible = false; continue; }
+      mesh.visible = true;
+      const v = mat[r][c];
+      const mag = Math.min(1.0, Math.abs(v) / amax);
+      const color = mag < 0.04 ? C_ZERO : baseColor;
+      mesh.material.color.setHex(color);
+      mesh.material.opacity = 0.18 + 0.75 * mag;
+    }
+  }
+}
+
+function _updateHeatmaps() {
+  _paintHeat(_heatStd,     S.scoresStd, C_STD);
+  _paintHeat(_heatKeyless, S.scoresKey, C_KEYLESS);
+}
+
+// cache-size bars: height ∝ entry count (standard is exactly 2× keyless), so
+// the 50% shrink is visible directly. Fidelity bar: height ∝ cosine_mean.
+function _updateBars() {
+  const live = S.state === "live";
+
+  function setCacheBar(mesh, entries, refMax, color) {
+    if (!mesh) return;
+    if (!live || entries == null) {
+      mesh.material.color.setHex(C_DIM);
+      mesh.material.emissive.setHex(C_DIM);
+      mesh.material.opacity = 0.3;
+      mesh.scale.y = 0.05;
+      mesh.position.y = 0.025;
+      return;
+    }
+    const h = Math.max(0.08, (entries / (refMax || 1)) * 3.0);
+    mesh.scale.y = h;
+    mesh.position.y = h * 0.5;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = 0.4;
+    mesh.material.opacity = 0.92;
+  }
+
+  const refMax = (S.kvEntStd != null && S.kvEntStd > 0) ? S.kvEntStd : 1;
+  setCacheBar(_barStd,     S.kvEntStd, refMax, C_STD);
+  setCacheBar(_barKeyless, S.kvEntKey, refMax, C_KEYLESS);
+
+  // fidelity bar — cosine_mean mapped from [-1,1] to a positive height
+  if (_barFid) {
+    if (!live || S.cosMean == null) {
+      _barFid.material.color.setHex(C_DIM);
+      _barFid.material.emissive.setHex(C_DIM);
+      _barFid.material.opacity = 0.3;
+      _barFid.scale.y = 0.05;
+      _barFid.position.y = 0.025;
+    } else {
+      const h = Math.max(0.08, ((S.cosMean + 1.0) / 2.0) * 3.0);
+      _barFid.scale.y = h;
+      _barFid.position.y = h * 0.5;
+      _barFid.material.color.setHex(C_FID);
+      _barFid.material.emissive.setHex(C_FID);
+      _barFid.material.emissiveIntensity = 0.4;
+      _barFid.material.opacity = 0.92;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.12;
+}
+
+// =============================================================================
+// 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 =
+    'Keyless Attention <b>eliminates the key projection</b> entirely: a value-space <b>routing matrix R</b> ' +
+    'replaces W<sub>k</sub>, so logits are formed as softmax((Q\u00b7R)\u00b7V\u1d40/\u221ad) and the decode ' +
+    'cache stores <b>values only</b>. Standard QKV attention caches both K and V (2\u00b7L\u00b7d); keyless caches ' +
+    'V alone (L\u00b7d) \u2014 an <b>exactly 50%</b> reduction. Panels: cache-size bars (standard vs keyless), ' +
+    'attention-map heatmaps (standard vs keyless), and an output-fidelity bar (mean per-token cosine similarity ' +
+    'between the two outputs). Honesty label <b>MODELED</b> (deterministic mechanism reproduction on a toy ' +
+    'sequence; trains nothing). 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 = "keyless attention \u00b7 value-only cache";
+  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("kl-dims",     "sequence (L \u00d7 d)"));
+  grid.appendChild(kpiRow("kl-m",        "factorization depth m"));
+  grid.appendChild(kpiRow("kl-entstd",   "cache entries \u2014 STANDARD (K+V)"));
+  grid.appendChild(kpiRow("kl-entkey",   "cache entries \u2014 KEYLESS (V-only)"));
+  grid.appendChild(kpiRow("kl-bytestd",  "cache bytes \u2014 STANDARD"));
+  grid.appendChild(kpiRow("kl-bytekey",  "cache bytes \u2014 KEYLESS"));
+  grid.appendChild(kpiRow("kl-reduction","KV-cache reduction"));
+  grid.appendChild(kpiRow("kl-cosmean",  "output fidelity \u2014 mean cosine (MEASURED)"));
+  grid.appendChild(kpiRow("kl-cosmin",   "output fidelity \u2014 min cosine"));
+  grid.appendChild(kpiRow("kl-mse",      "output MSE (standard vs keyless)"));
+  grid.appendChild(kpiRow("kl-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 = "Keyless Attention \u2014 Xin Gao, \u201cValue-Space Routing and Value-Only Caching for Efficient Transformers\u201d arXiv:2606.21848 (arxiv.org/abs/2606.21848). MODELED \u00b7 mechanism demo on a toy sequence, not a trained transformer.";
+  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 = "kl-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 red  = S.reduction != null ? S.reduction.toFixed(1) + "%" : "loading\u2026";
+  const cos  = S.cosMean   != null ? S.cosMean.toFixed(3)         : "loading\u2026";
+  const bs   = S.kvBytesStd != null ? S.kvBytesStd + " B"         : "loading\u2026";
+  const bk   = S.kvBytesKey != null ? S.kvBytesKey + " B"         : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> To generate text fast, a model keeps a running memory of every earlier word \u2014 " +
+    "the \u201cKV cache.\u201d Normally it stores two things per word (a <b>key</b> and a <b>value</b>). Keyless " +
+    "Attention throws away the key entirely and reroutes the lookup through the values themselves, so it only " +
+    "stores <b>one</b> thing per word. That halves the memory: here from about <b>" + bs + "</b> down to <b>" +
+    bk + "</b> \u2014 a <b>" + red + "</b> cut. On this small synthetic test the two methods produce outputs " +
+    "that overlap with an average cosine similarity of about <b>" + cos + "</b>. This view is a <b>MODELED</b> " +
+    "deterministic reproduction of that cache-halving MECHANISM on a tiny synthetic sequence \u2014 it <b>trains " +
+    "no model</b> and runs no GPU kernel. The paper\u2019s headline that keyless matches or beats standard " +
+    "attention on <b>real</b> models (GPT-2, Pythia, Qwen2, Llama 3.2) is a <b>claim about real training runs</b> " +
+    "the estate does not independently verify.";
+}
+
+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("kl-dims",      t || ((S.L != null && S.d != null) ? (S.L + " \u00d7 " + S.d) : "\u2014"));
+  _set("kl-m",         t || (S.m != null ? String(S.m) : "\u2014"));
+  _set("kl-entstd",    t || (S.kvEntStd != null ? String(S.kvEntStd) : "\u2014"));
+  _set("kl-entkey",    t || (S.kvEntKey != null ? String(S.kvEntKey) : "\u2014"));
+  _set("kl-bytestd",   t || (S.kvBytesStd != null ? (S.kvBytesStd + " B") : "\u2014"));
+  _set("kl-bytekey",   t || (S.kvBytesKey != null ? (S.kvBytesKey + " B") : "\u2014"));
+  _set("kl-reduction", t || (S.reduction != null ? (S.reduction.toFixed(1) + "%") : "\u2014"));
+  _set("kl-cosmean",   t || fx(S.cosMean, 4));
+  _set("kl-cosmin",    t || fx(S.cosMin, 4));
+  _set("kl-mse",       t || fx(S.mse, 4));
+  // honesty label verbatim — never upgraded
+  _set("kl-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;
+  _heatStd = []; _heatKeyless = []; _heatGroup = null;
+  _barStd = null; _barKeyless = null; _barFid = null; _barGroup = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.L = S.d = S.m = null;
+  S.bytesPer = S.kvEntStd = S.kvEntKey = S.kvBytesStd = S.kvBytesKey = null;
+  S.reduction = S.cosMean = S.cosMin = S.mse = null;
+  S.scoresStd = S.scoresKey = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };