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

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

@@ -95,6 +95,10 @@ const SURFACES = [
   { id: "mor", title: "Mixture-of-Recursions (adaptive depth)", mod: "/static/3d/surfaces/mor.js" },
   { id: "goat", title: "GOAT Optimal-Transport Attention", mod: "/static/3d/surfaces/goat.js" },
   { id: "kla", title: "Kaczmarz Linear Attention", mod: "/static/3d/surfaces/kla.js" },
+  { id: "hrm", title: "Hierarchical Reasoning Model", mod: "/static/3d/surfaces/hrm.js" },
+  { id: "pfield", title: "Pressure-Field Coordination", mod: "/static/3d/surfaces/pfield.js" },
+  { id: "qhall", title: "Quantum-Inspired Hallucination UQ", mod: "/static/3d/surfaces/qhall.js" },
+  { id: "aimc", title: "Analog In-Memory Attention", mod: "/static/3d/surfaces/aimc.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/aimc.js

@@ -0,0 +1,508 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/aimc.js — ANALOG IN-MEMORY COMPUTING ATTENTION organ for the
+// holographic frontier ring (charge-domain gain-cell crossbar attention,
+// Leroux et al. 2025-style). Renders an idealized analog crossbar as a lattice
+// of nodes: the query drives charge along columns to compute query·key
+// dot-products IN MEMORY. Three score bars per column visualize the exact
+// DIGITAL baseline (lattice-blue), the raw NOISY ANALOG pathway (violet-blue),
+// and the CALIBRATED analog pathway (proof-teal) that recovers accuracy. A HUD
+// shows analog_mse vs calibrated_mse + the operations-avoided energy tally read
+// live from /api/killinchu/v1/aimc/attend. Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors mla.js / kvcache.js / specdecode.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   seq_len, dim, noise_sigma, analog_mse, calibrated_mse, calibration_gain,
+//   accuracy_recovered_pct, adc_dac_ops_avoided, memory_move_reads_avoided,
+//   total_ops_avoided, paper_energy_reduction_claim, paper_latency_reduction_claim,
+//   sample_digital_scores[], sample_analog_scores[], sample_calibrated_scores[]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   AIMC attention — analog in-memory gain-cell crossbar attention (mechanism
+//   simulated here):
+//     Leroux et al. 2025, Nature Computational Science
+//     https://www.nature.com/articles/s43588-025-00854-1
+//   IBM Research plain-language summary (reference):
+//     https://research.ibm.com/blog/how-can-analog-in-memory-computing-power-transformer-models
+//
+// HONESTY LABELS: MODELED (deterministic simulation of the charge-domain crossbar
+//   attention arithmetic on ordinary CPU floats; NOT a run on real analog gain-cell
+//   hardware; NEVER-CLAIMED-AS the Leroux et al. chip). Read verbatim from JSON;
+//   never upgraded here. CRITICAL HONESTY: the energy/latency advantage figures are
+//   the PAPER's published CLAIM reproduced at toy scale via an operations-avoided
+//   accounting model — NOT measured on real analog hardware, NOT a measured SZL
+//   result. Doctrine v11: never claim more than is real.
+// COLOURS: lattice-blue 0x5b8dee (exact digital baseline / crossbar rows), violet-
+//   blue 0x8a6bff (raw noisy analog pathway), proof-teal 0x3af4c8 (calibrated
+//   pathway / HUD accent), greys (device-noise / degraded state). Purple BANNED as
+//   UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via 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    = "aimc";
+const TITLE = "Analog In-Memory Computing Attention · Gain-Cell Crossbar (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the AIMC organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/aimc/attend?seed=42&seq_len=128&dim=64&noise_sigma=0.05";
+
+// data-viz hues — purple BANNED
+const C_DIGITAL = 0x5b8dee;  // lattice-blue (exact digital baseline / crossbar rows)
+const C_ANALOG  = 0x8a6bff;  // violet-blue (raw noisy analog pathway)
+const C_CALIB   = 0x3af4c8;  // proof-teal (calibrated pathway / HUD accent)
+const C_NOISE   = 0x6b7a86;  // grey (device-noise cue)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// crossbar + score-bar layout geometry
+const GRID_N     = 8;       // crossbar rendered as GRID_N x GRID_N node lattice
+const NODE_GAP   = 0.5;     // world-units between crossbar nodes
+const BAR_GAP    = 0.5;     // world-units between score-bar columns along X
+const MAX_BARS   = 24;      // cap on score-bar columns rendered (perf)
+const MAX_BAR_H  = 5.0;     // world-units — score bar height at unit score
+const MIN_BAR_H  = 0.04;    // floor height so a bar never fully vanishes
+
+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 _crossbar   = [];               // Array<THREE.Mesh> — crossbar lattice nodes
+let _crossLines = [];               // Array<THREE.Line> — crossbar row/column wires
+let _barsDig    = [];               // Array<THREE.Mesh> — digital baseline score bars
+let _barsAna    = [];               // Array<THREE.Mesh> — raw analog score bars
+let _barsCal    = [];               // Array<THREE.Mesh> — calibrated score bars
+let _query      = null;             // THREE.Mesh — pulsing query-drive marker
+
+// live state
+const S = {
+  label:        null,
+  seqLen:       null,   // seq_len
+  dim:          null,   // dim
+  noiseSigma:   null,   // noise_sigma
+  analogMse:    null,   // analog_mse
+  calibMse:     null,   // calibrated_mse
+  calibGain:    null,   // calibration_gain
+  accRecovered: null,   // accuracy_recovered_pct
+  adcDacOps:    null,   // adc_dac_ops_avoided
+  memMoveOps:   null,   // memory_move_reads_avoided
+  totalOps:     null,   // total_ops_avoided
+  energyClaim:  null,   // paper_energy_reduction_claim (PAPER's claim, not measured)
+  latencyClaim: null,   // paper_latency_reduction_claim (PAPER's claim, not measured)
+  digScores:    null,   // sample_digital_scores[]
+  anaScores:    null,   // sample_analog_scores[]
+  calScores:    null,   // sample_calibrated_scores[]
+  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, 6, 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();
+  _buildCrossbar();
+  _buildScoreBars();
+  _buildQuery();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onAimc, { 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;
+}
+
+// Idealized analog gain-cell crossbar: a GRID_N x GRID_N lattice of nodes with
+// row + column wires. Each node stores a Key element; the query drives charge
+// down the columns to accumulate the dot-product IN MEMORY.
+function _buildCrossbar() {
+  const THREE = _THREE;
+  const nodeGeo = new THREE.OctahedronGeometry(0.09, 0);
+  const originX = -5.0, baseY = 0.6, baseZ = -1.8;
+
+  for (let r = 0; r < GRID_N; r++) {
+    for (let c = 0; c < GRID_N; c++) {
+      const mesh = new THREE.Mesh(
+        nodeGeo,
+        new THREE.MeshStandardMaterial({ color: C_NOISE, emissive: C_NOISE, emissiveIntensity: 0.2, transparent: true, opacity: 0.75 }),
+      );
+      mesh.position.set(originX + c * NODE_GAP, baseY + r * NODE_GAP, baseZ);
+      _group.add(mesh);
+      _crossbar.push(mesh);
+    }
+  }
+  // row wires (lattice-blue) + column wires (proof-teal charge paths)
+  for (let r = 0; r < GRID_N; r++) {
+    const pts = [
+      new THREE.Vector3(originX, baseY + r * NODE_GAP, baseZ),
+      new THREE.Vector3(originX + (GRID_N - 1) * NODE_GAP, baseY + r * NODE_GAP, baseZ),
+    ];
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const line = new THREE.Line(geo, new THREE.LineBasicMaterial({ color: C_DIGITAL, transparent: true, opacity: 0.3 }));
+    _group.add(line); _crossLines.push(line);
+  }
+  for (let c = 0; c < GRID_N; c++) {
+    const pts = [
+      new THREE.Vector3(originX + c * NODE_GAP, baseY, baseZ),
+      new THREE.Vector3(originX + c * NODE_GAP, baseY + (GRID_N - 1) * NODE_GAP, baseZ),
+    ];
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const line = new THREE.Line(geo, new THREE.LineBasicMaterial({ color: C_CALIB, transparent: true, opacity: 0.25 }));
+    _group.add(line); _crossLines.push(line);
+  }
+}
+
+// Three interleaved score-bar columns per position: exact digital baseline
+// (lattice-blue), raw noisy analog (violet-blue), calibrated (proof-teal).
+// We scale each bar's Y in-place as live data arrives (no per-poll churn),
+// base centered at y=0 via geometry translation so scaling grows upward.
+function _buildScoreBars() {
+  const THREE = _THREE;
+  const barGeo = new THREE.BoxGeometry(0.12, 1, 0.12);
+  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;
+  }
+  for (let i = 0; i < MAX_BARS; i++) {
+    const x = i * BAR_GAP;
+    const bd = mkBar(C_DIGITAL, 0.3); bd.position.set(x - 0.14, 0, 0.4);
+    const ba = mkBar(C_ANALOG, 0.34); ba.position.set(x,       0, 0.4);
+    const bc = mkBar(C_CALIB, 0.42);  bc.position.set(x + 0.14, 0, 0.4);
+    _barsDig.push(bd); _barsAna.push(ba); _barsCal.push(bc);
+  }
+}
+
+function _buildQuery() {
+  const THREE = _THREE;
+  _query = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.28, 1),
+    new THREE.MeshStandardMaterial({ color: C_CALIB, emissive: C_CALIB, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _query.position.set(-5.7, 2.4, -1.8);
+  _group.add(_query);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onAimc(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.seqLen       = typeof src.seq_len                 === "number" ? src.seq_len                 : null;
+  S.dim          = typeof src.dim                     === "number" ? src.dim                     : null;
+  S.noiseSigma   = typeof src.noise_sigma             === "number" ? src.noise_sigma             : null;
+  S.analogMse    = typeof src.analog_mse              === "number" ? src.analog_mse              : null;
+  S.calibMse     = typeof src.calibrated_mse          === "number" ? src.calibrated_mse          : null;
+  S.calibGain    = typeof src.calibration_gain        === "number" ? src.calibration_gain        : null;
+  S.accRecovered = typeof src.accuracy_recovered_pct  === "number" ? src.accuracy_recovered_pct  : null;
+  S.adcDacOps    = typeof src.adc_dac_ops_avoided     === "number" ? src.adc_dac_ops_avoided     : null;
+  S.memMoveOps   = typeof src.memory_move_reads_avoided === "number" ? src.memory_move_reads_avoided : null;
+  S.totalOps     = typeof src.total_ops_avoided       === "number" ? src.total_ops_avoided       : null;
+  S.energyClaim  = typeof src.paper_energy_reduction_claim  === "string" ? src.paper_energy_reduction_claim  : null;
+  S.latencyClaim = typeof src.paper_latency_reduction_claim === "string" ? src.paper_latency_reduction_claim : null;
+  S.digScores    = Array.isArray(src.sample_digital_scores)    ? src.sample_digital_scores    : null;
+  S.anaScores    = Array.isArray(src.sample_analog_scores)     ? src.sample_analog_scores     : null;
+  S.calScores    = Array.isArray(src.sample_calibrated_scores) ? src.sample_calibrated_scores : null;
+
+  _updateBars();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the score bars + crossbar tint from live data
+// =============================================================================
+function _updateBars() {
+  const live = S.state === "live";
+  const dig = live && S.digScores ? S.digScores : [];
+  const ana = live && S.anaScores ? S.anaScores : [];
+  const cal = live && S.calScores ? S.calScores : [];
+
+  // normalize bar heights against the max absolute digital score so the trio
+  // is comparable per column.
+  let maxAbs = 0.0;
+  for (let i = 0; i < dig.length; i++) { const a = Math.abs(dig[i]); if (a > maxAbs) maxAbs = a; }
+  if (maxAbs <= 1e-9) maxAbs = 1.0;
+
+  for (let i = 0; i < MAX_BARS; i++) {
+    const has = live && i < dig.length;
+    _barsDig[i].visible = has;
+    _barsAna[i].visible = has;
+    _barsCal[i].visible = has;
+    if (!has) continue;
+    const hd = Math.max(MIN_BAR_H, (Math.abs(dig[i]) / maxAbs) * MAX_BAR_H);
+    const ha = Math.max(MIN_BAR_H, (Math.abs(ana[i] != null ? ana[i] : dig[i]) / maxAbs) * MAX_BAR_H);
+    const hc = Math.max(MIN_BAR_H, (Math.abs(cal[i] != null ? cal[i] : dig[i]) / maxAbs) * MAX_BAR_H);
+    _barsDig[i].scale.y = hd;
+    _barsAna[i].scale.y = ha;
+    _barsCal[i].scale.y = hc;
+  }
+
+  // crossbar node tint: violet-blue when live (charge flowing), grey degraded.
+  const nodeColor = live ? C_ANALOG : C_DIM;
+  for (let n = 0; n < _crossbar.length; n++) {
+    _crossbar[n].material.color.setHex(nodeColor);
+    _crossbar[n].material.emissive.setHex(nodeColor);
+    _crossbar[n].material.opacity = live ? 0.75 : 0.2;
+  }
+  for (let l = 0; l < _crossLines.length; l++) {
+    _crossLines[l].material.opacity = live ? 0.28 : 0.08;
+  }
+  if (_query) {
+    const qc = live ? C_CALIB : C_DIM;
+    _query.material.color.setHex(qc);
+    _query.material.emissive.setHex(qc);
+    _query.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.11;
+  if (_query) {
+    _query.rotation.y += 0.02;
+    _query.rotation.x += 0.011;
+    const pulse = 1.0 + 0.14 * Math.sin(t * 0.004);
+    _query.scale.setScalar(pulse);
+  }
+  // gentle shimmer along crossbar nodes to suggest charge accumulation
+  for (let n = 0; n < _crossbar.length; n++) {
+    const m = _crossbar[n];
+    m.material.emissiveIntensity = 0.2 + 0.12 * (0.5 + 0.5 * Math.sin(t * 0.003 + n * 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%,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 =
+    'Instead of moving the KV cache out of memory and through ADC/DAC converters, an analog ' +
+    '<b>gain-cell crossbar</b> stores the Keys and computes query\u00b7key dot-products as a ' +
+    'physical <b>charge-domain multiply-accumulate</b> in place. Bars per column compare the ' +
+    'exact <b>digital</b> baseline (lattice-blue), the raw <b>analog</b> pathway with device ' +
+    'noise (violet-blue), and the <b>calibrated</b> pathway (proof-teal) that recovers accuracy. ' +
+    'Honesty label <b>MODELED</b> \u2014 a deterministic simulation on ordinary CPU floats, NOT ' +
+    'real analog hardware. Energy/latency wins shown are the <b>paper\u2019s claim, not a measured ' +
+    'SZL result</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 = "analog in-memory computing attention";
+  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:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("ai-seqlen",  "seq_len (crossbar columns)"));
+  grid.appendChild(kpiRow("ai-dim",     "dim (crossbar rows)"));
+  grid.appendChild(kpiRow("ai-noise",   "noise_sigma (device imprecision)"));
+  grid.appendChild(kpiRow("ai-anamse",  "analog_mse (raw, vs digital)"));
+  grid.appendChild(kpiRow("ai-calmse",  "calibrated_mse (vs digital) \u2014 MODELED"));
+  grid.appendChild(kpiRow("ai-acc",     "accuracy_recovered_pct"));
+  grid.appendChild(kpiRow("ai-ops",     "total_ops_avoided (ADC/DAC + moves)"));
+  grid.appendChild(kpiRow("ai-energy",  "energy reduction (paper\u2019s claim)"));
+  grid.appendChild(kpiRow("ai-latency", "latency reduction (paper\u2019s claim)"));
+  grid.appendChild(kpiRow("ai-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.innerHTML = "AIMC attention \u2014 Leroux et al. 2025, Nature Computational Science " +
+    "(nature.com/articles/s43588-025-00854-1) \u00b7 IBM Research summary. MODELED \u00b7 not " +
+    "claimed-as. Energy/latency = paper\u2019s claim, NOT a measured SZL figure.";
+  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 = "ai-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 acc = S.accRecovered != null ? S.accRecovered.toFixed(1) + "%" : "loading\u2026";
+  const ops = S.totalOps     != null ? S.totalOps.toLocaleString() : "loading\u2026";
+  const nz  = S.noiseSigma   != null ? S.noiseSigma.toFixed(3) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Today a chip has to haul the model\u2019s attention \u201cmemory\u201d " +
+    "(the KV cache) out of storage and convert it back and forth through analog\u2194digital " +
+    "converters just to do the math \u2014 that shuttling is where most of the energy and time " +
+    "goes. <b>Analog in-memory computing</b> stores those numbers as tiny electrical charges " +
+    "and lets the math happen <i>inside the memory itself</i>: the query flows in as a voltage " +
+    "and the answer literally adds itself up along each wire. Because the storage is analog it " +
+    "is slightly imprecise (device noise, here <b>" + nz + "</b>), but a one-time <b>calibration</b> " +
+    "step rescales the results and recovers about <b>" + acc + "</b> of the lost accuracy. Skipping " +
+    "the conversions and the memory shuttling avoids roughly <b>" + ops + "</b> operations at this " +
+    "toy scale. <b>Important honesty note:</b> the huge energy (up to ~100,000\u00d7) and latency " +
+    "(up to ~100\u00d7) savings are the <b>research paper\u2019s published claim</b> for real analog " +
+    "hardware \u2014 they are <b>NOT measured on real hardware here and NOT a measured SZL result</b>. " +
+    "This view is a <b>MODELED</b> deterministic simulation running on an ordinary digital CPU, " +
+    "not a run of the actual analog chip.";
+}
+
+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("ai-seqlen",  t || (S.seqLen != null ? S.seqLen.toLocaleString() : "\u2014"));
+  _set("ai-dim",     t || (S.dim != null ? String(S.dim) : "\u2014"));
+  _set("ai-noise",   t || fx(S.noiseSigma, 3));
+  _set("ai-anamse",  t || fx(S.analogMse, 6));
+  _set("ai-calmse",  t || fx(S.calibMse, 6));
+  _set("ai-acc",     t || (S.accRecovered != null ? S.accRecovered.toFixed(2) + "%" : "\u2014"));
+  _set("ai-ops",     t || (S.totalOps != null ? S.totalOps.toLocaleString() : "\u2014"));
+  // energy/latency figures are the PAPER's claim, NOT a measured SZL result.
+  _set("ai-energy",  t || (S.energyClaim != null ? S.energyClaim : "paper\u2019s claim, not measured SZL"));
+  _set("ai-latency", t || (S.latencyClaim != null ? S.latencyClaim : "paper\u2019s claim, not measured SZL"));
+  // honesty label verbatim — never upgraded
+  _set("ai-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; _crossbar = []; _crossLines = [];
+  _barsDig = []; _barsAna = []; _barsCal = []; _query = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.seqLen = S.dim = S.noiseSigma = null;
+  S.analogMse = S.calibMse = S.calibGain = S.accRecovered = null;
+  S.adcDacOps = S.memMoveOps = S.totalOps = null;
+  S.energyClaim = S.latencyClaim = null;
+  S.digScores = S.anaScores = S.calScores = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/hrm.js

@@ -0,0 +1,497 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/hrm.js — HIERARCHICAL REASONING MODEL (HRM) organ for the
+// holographic frontier ring. Renders the two-timescale H-slow / L-fast control
+// loop solving a toy mini-Sudoku Latin-square grid: a live 3D grid whose cells
+// fill in as the FAST low-level executor (L) propagates local constraints and
+// the SLOW high-level planner (H) advances an abstract-plan bar once per tick.
+// Live snapshot comes from /api/killinchu/v1/hrm/solve.
+//
+// >>> HONESTY IS THE POINT OF THIS ORGAN <<<
+//   Per the ARC Prize independent analysis (arcprize.org/blog/hrm-analysis),
+//   the H/L hierarchy is NOT the dominant driver of HRM's headline results — a
+//   parameter-matched single-module Transformer came within ~5pp. So this
+//   surface renders the H/L result BESIDE a size-matched FLAT single-module
+//   baseline (same total update budget) and states the caveat plainly in the
+//   "what this means" copy. It does NOT repeat the paper's stronger framing.
+//
+// Surface export shape (mirrors mor.js / specdecode.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   n, h_ticks, l_steps, clues, empty_start, hierarchical{solved,h_ticks_used,
+//   l_updates_total,guided_placements,h_plan_trace[],filled_trace[]},
+//   flat_baseline{solved,refine_rounds,l_updates_total,guided_placements},
+//   hierarchy_edge{both_solved,hier_updates_total,flat_updates_total,
+//   l_updates_delta,updates_ratio,verdict}, final_grid[][], solution_grid[][],
+//   caveat
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Hierarchical Reasoning Model (two-timescale H/L architecture modeled here):
+//     Wang et al. 2025, arXiv:2506.21734  https://arxiv.org/abs/2506.21734
+//   Official HRM code (reference only): github.com/sapientinc/HRM
+//   ARC Prize independent analysis (the honesty caveat source):
+//     https://arcprize.org/blog/hrm-analysis
+//   ARC Prize analysis code (reference only):
+//     github.com/arcprize/hierarchical-reasoning-model-analysis
+//
+// HONESTY LABELS: MODELED (deterministic re-implementation of the H/L control
+//   loop on a toy grid; NOT the HRM network; NEVER-CLAIMED-AS production). Read
+//   verbatim from JSON; never upgraded here. The endpoint puts the label at the
+//   TOP LEVEL of its JSON response (j.label); we read that (with a defensive
+//   nested payload.label fallback) and display it as-is.
+// COLOURS: lattice-blue 0x5b8dee (empty / shallow), violet-blue 0x8a6bff
+//   (guided / H-planner accent), proof-teal 0x3af4c8 (solved cell / HUD
+//   accent), greys (degraded / no-live-data). 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    = "hrm";
+const TITLE = "Hierarchical Reasoning Model · H-slow / L-fast (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the HRM organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/hrm/solve?seed=42&n=4&h_ticks=12&l_steps=8";
+
+// data-viz hues — purple BANNED.
+const C_EMPTY   = 0x5b8dee;  // lattice-blue (empty / freshly-considered cell)
+const C_GUIDED  = 0x8a6bff;  // violet-blue  (H-planner top-down guided placement)
+const C_SOLVED  = 0x3af4c8;  // proof-teal   (filled/solved cell / HUD accent)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// grid layout geometry
+const MAX_N     = 9;    // largest grid side we pre-allocate cells for
+const CELL      = 1.15; // world-units between grid cells
+const MAX_CELLS = MAX_N * MAX_N;
+
+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 _cellMesh  = [];    // Array<THREE.Mesh> — one per grid cell (n×n active subset)
+let _planBar   = null;  // THREE.Mesh — H-slow abstract-plan progress bar
+let _flatBar   = null;  // THREE.Mesh — flat-baseline progress bar (honest ablation)
+let _marker    = null;  // THREE.Mesh — HUD "converged" pulsing marker
+
+// live state
+const S = {
+  label:        null,
+  n:            null,   // grid side
+  hTicks:       null,   // h_ticks (budget)
+  lSteps:       null,   // l_steps
+  clues:        null,   // clues
+  emptyStart:   null,   // empty_start
+  hier:         null,   // hierarchical{...}
+  flat:         null,   // flat_baseline{...}
+  edge:         null,   // hierarchy_edge{...}
+  finalGrid:    null,   // final_grid[][]
+  caveat:       null,   // caveat string
+  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, 9, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 1, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildGrid();
+  _buildBars();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onHrm, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); _updateScene(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(30, 30, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Pre-allocate MAX_N×MAX_N cell meshes; we position/show only the active n×n
+// subset per poll (no geometry churn). Each cell is a small tile that rises &
+// recolours as it gets filled by the L-executor / H-planner.
+function _buildGrid() {
+  const THREE = _THREE;
+  const cellGeo = new THREE.BoxGeometry(CELL * 0.8, 0.5, CELL * 0.8);
+  for (let i = 0; i < MAX_CELLS; i++) {
+    const mesh = new THREE.Mesh(
+      cellGeo,
+      new THREE.MeshStandardMaterial({ color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.12, transparent: true, opacity: 0.0 }),
+    );
+    mesh.visible = false;
+    _group.add(mesh);
+    _cellMesh.push(mesh);
+  }
+}
+
+// Two upright progress bars behind the grid: the H-slow abstract-plan bar
+// (proof-teal) and the size-matched FLAT baseline bar (violet-blue). Showing
+// them side by side is the honest ablation — they end up nearly equal.
+function _buildBars() {
+  const THREE = _THREE;
+  const barGeo = new THREE.BoxGeometry(0.7, 1.0, 0.7);
+  _planBar = new THREE.Mesh(
+    barGeo,
+    new THREE.MeshStandardMaterial({ color: C_SOLVED, emissive: C_SOLVED, emissiveIntensity: 0.35, transparent: true, opacity: 0.0 }),
+  );
+  _planBar.position.set(-1.1, 0.02, -(MAX_N * CELL * 0.5) - 1.6);
+  _planBar.scale.y = 0.05;
+  _group.add(_planBar);
+
+  _flatBar = new THREE.Mesh(
+    barGeo,
+    new THREE.MeshStandardMaterial({ color: C_GUIDED, emissive: C_GUIDED, emissiveIntensity: 0.3, transparent: true, opacity: 0.0 }),
+  );
+  _flatBar.position.set(1.1, 0.02, -(MAX_N * CELL * 0.5) - 1.6);
+  _flatBar.scale.y = 0.05;
+  _group.add(_flatBar);
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.30, 1),
+    new THREE.MeshStandardMaterial({ color: C_SOLVED, emissive: C_SOLVED, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, 4.0, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onHrm(j) {
+  // read honesty label VERBATIM — never upgrade. Endpoint puts label at the
+  // TOP LEVEL of the JSON (this module's own response shape), so read j.label;
+  // fall back to a nested payload.label defensively in case of a wrapper.
+  const rawLabel = (j && typeof j.label === "string") ? j.label
+                 : (j && j.payload && typeof j.payload.label === "string") ? j.payload.label
+                 : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : (j || {});
+
+  S.label      = String(rawLabel).toUpperCase();
+  S.n          = typeof src.n           === "number" ? src.n           : null;
+  S.hTicks     = typeof src.h_ticks     === "number" ? src.h_ticks     : null;
+  S.lSteps     = typeof src.l_steps     === "number" ? src.l_steps     : null;
+  S.clues      = typeof src.clues       === "number" ? src.clues       : null;
+  S.emptyStart = typeof src.empty_start === "number" ? src.empty_start : null;
+  S.hier       = (src.hierarchical && typeof src.hierarchical === "object") ? src.hierarchical : null;
+  S.flat       = (src.flat_baseline && typeof src.flat_baseline === "object") ? src.flat_baseline : null;
+  S.edge       = (src.hierarchy_edge && typeof src.hierarchy_edge === "object") ? src.hierarchy_edge : null;
+  S.finalGrid  = Array.isArray(src.final_grid) ? src.final_grid : null;
+  S.caveat     = typeof src.caveat === "string" ? src.caveat : null;
+
+  _updateScene();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the grid + progress bars from live data
+// =============================================================================
+function _updateScene() {
+  const live = S.state === "live";
+  const n = live && S.n ? Math.min(S.n, MAX_N) : 0;
+  const grid = live && S.finalGrid ? S.finalGrid : null;
+
+  // --- solved-grid tiles ---
+  const x0 = -(n - 1) * CELL * 0.5;
+  const z0 = -(n - 1) * CELL * 0.5;
+  for (let i = 0; i < MAX_CELLS; i++) {
+    const mesh = _cellMesh[i];
+    if (!live || n <= 0 || i >= n * n) { mesh.visible = false; continue; }
+    const r = (i / n) | 0;
+    const c = i % n;
+    mesh.visible = true;
+    mesh.position.set(x0 + c * CELL, 0.25, z0 + r * CELL);
+    const filled = grid && grid[r] && typeof grid[r][c] === "number" && grid[r][c] !== 0;
+    // solved cells glow proof-teal and rise; unfilled cells stay low lattice-blue
+    const color = filled ? C_SOLVED : C_EMPTY;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = filled ? 0.5 : 0.16;
+    mesh.material.opacity = filled ? 0.95 : 0.4;
+    const h = filled ? 0.9 : 0.25;
+    mesh.scale.y = h;
+    mesh.position.y = h * 0.5;
+  }
+
+  // --- H-slow plan bar (proof-teal): final abstract-plan value (fraction filled) ---
+  if (_planBar) {
+    const trace = live && S.hier && Array.isArray(S.hier.h_plan_trace) ? S.hier.h_plan_trace : null;
+    const plan = trace && trace.length ? trace[trace.length - 1] : (live && S.hier && S.hier.solved ? 1 : 0);
+    if (live && plan != null) {
+      _planBar.material.color.setHex(C_SOLVED); _planBar.material.emissive.setHex(C_SOLVED);
+      _planBar.material.opacity = 0.9;
+      const h = 0.15 + plan * 3.4; _planBar.scale.y = h; _planBar.position.y = h * 0.5;
+    } else {
+      _planBar.material.color.setHex(C_DIM); _planBar.material.emissive.setHex(C_DIM);
+      _planBar.material.opacity = 0.3; _planBar.scale.y = 0.05; _planBar.position.y = 0.02;
+    }
+  }
+
+  // --- FLAT baseline bar (violet-blue): honest ablation, ends up near-equal ---
+  if (_flatBar) {
+    const flatSolved = live && S.flat && S.flat.solved;
+    const flatFrac = flatSolved ? 1 : (live && S.emptyStart != null && S.n != null && S.flat
+      ? Math.max(0, Math.min(1, (S.n * S.n - (S.emptyStart - (S.flat.l_updates_total || 0))) / (S.n * S.n)))
+      : 0);
+    if (live) {
+      _flatBar.material.color.setHex(C_GUIDED); _flatBar.material.emissive.setHex(C_GUIDED);
+      _flatBar.material.opacity = 0.9;
+      const h = 0.15 + flatFrac * 3.4; _flatBar.scale.y = h; _flatBar.position.y = h * 0.5;
+    } else {
+      _flatBar.material.color.setHex(C_DIM); _flatBar.material.emissive.setHex(C_DIM);
+      _flatBar.material.opacity = 0.3; _flatBar.scale.y = 0.05; _flatBar.position.y = 0.02;
+    }
+  }
+
+  // --- converged marker ---
+  if (_marker) {
+    if (live && S.hier && S.hier.solved) {
+      _marker.material.color.setHex(C_SOLVED); _marker.material.emissive.setHex(C_SOLVED);
+      _marker.material.opacity = 0.85; _marker.scale.setScalar(1.0);
+    } else {
+      _marker.material.color.setHex(C_DIM); _marker.material.emissive.setHex(C_DIM);
+      _marker.material.opacity = 0.3; _marker.scale.setScalar(0.7);
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.16;
+  if (_marker) {
+    _marker.rotation.y += 0.022;
+    _marker.rotation.x += 0.011;
+    const pulse = 1.0 + 0.12 * Math.sin(t * 0.004);
+    _marker.scale.setScalar((S.hier && S.hier.solved ? 1.0 : 0.7) * 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 =
+    'Two interdependent recurrent modules at different timescales solve a mini-Sudoku: a ' +
+    '<b>fast low-level executor (L)</b> propagates local cell constraints to convergence, and a ' +
+    '<b>slow high-level planner (H)</b> advances an abstract plan once per tick and nudges the ' +
+    'executor when it stalls. Cells glow <b>teal</b> as they solve. ' +
+    'Honesty label <b>MODELED</b> (deterministic control-loop simulation on a toy grid; NOT the HRM network). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  // explicit honesty-caveat banner (the ARC Prize finding) — always shown
+  const dist = document.createElement("div");
+  dist.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.5;border:1px solid #26333f;border-radius:7px;padding:7px 9px;background:#0a1117";
+  dist.innerHTML =
+    '<b style="color:#3af4c8">Honesty caveat.</b> ' +
+    'Independent analysis by the <b>ARC Prize team</b> (arcprize.org/blog/hrm-analysis) found the ' +
+    'H/L <b>hierarchy is NOT the dominant driver</b> of HRM\u2019s headline results \u2014 a ' +
+    'parameter-matched <i>single-module</i> Transformer came within <b>~5 points</b>. The real ' +
+    'drivers were an <b>outer refinement loop</b>, heavy <b>data augmentation</b>, and a per-task ' +
+    '<b>puzzle-embedding</b>. So this organ shows the H/L result <i>beside</i> a size-matched ' +
+    '<b>flat baseline</b> (violet bar) \u2014 they end up nearly equal. We do <i>not</i> overclaim the hierarchy.';
+  _overlay.appendChild(dist);
+
+  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 = "hierarchical reasoning model";
+  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:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("hrm-grid",     "puzzle (mini-Sudoku n\u00d7n)"));
+  grid.appendChild(kpiRow("hrm-clues",    "clues / empty at start"));
+  grid.appendChild(kpiRow("hrm-hsolved",  "H/L hierarchical: solved?"));
+  grid.appendChild(kpiRow("hrm-hticks",   "H-slow ticks used"));
+  grid.appendChild(kpiRow("hrm-hupdates", "H/L total updates \u2014 MODELED"));
+  grid.appendChild(kpiRow("hrm-fsolved",  "flat baseline (size-matched): solved?"));
+  grid.appendChild(kpiRow("hrm-fupdates", "flat total updates \u2014 MODELED"));
+  grid.appendChild(kpiRow("hrm-ratio",    "updates ratio (hier / flat)"));
+  grid.appendChild(kpiRow("hrm-verdict",  "honest verdict"));
+  grid.appendChild(kpiRow("hrm-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 = "Wang et al. arXiv:2506.21734 (HRM) \u00b7 github.com/sapientinc/HRM \u00b7 ARC Prize analysis arcprize.org/blog/hrm-analysis. 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 = "hrm-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 nn      = S.n != null ? (S.n + "\u00d7" + S.n) : "small";
+  const hSolved = S.hier && S.hier.solved ? "yes" : "not yet";
+  const ratio   = S.edge && S.edge.updates_ratio != null ? S.edge.updates_ratio.toFixed(2) : "\u2248 1";
+  const verdict = S.edge && typeof S.edge.verdict === "string" ? S.edge.verdict : null;
+  pd.innerHTML =
+    "<b>What this means:</b> A hard puzzle (here a " + nn + " mini-Sudoku) is solved by two " +
+    "cooperating parts of one model running at different speeds: a <b>fast \u201cworker\u201d</b> that " +
+    "fills in whatever cells are locally forced, and a <b>slow \u201cplanner\u201d</b> that steps back " +
+    "once in a while to see the big picture and unstick the worker. It reaches the answer in a " +
+    "single pass, without writing out its reasoning step-by-step (solved: " + hSolved + "). " +
+    "<b>But here is the honest part:</b> the independent <b>ARC Prize</b> team re-examined HRM and " +
+    "found this slow/fast <i>hierarchy is not actually the main reason it works</i> \u2014 an " +
+    "ordinary <i>single-module</i> model of the same size got within about <b>5 points</b>. The real " +
+    "gains came from repeatedly <b>refining</b> the answer, lots of <b>data augmentation</b>, and " +
+    "<b>memorizing each puzzle\u2019s identity</b>. To keep us honest, this view runs a size-matched " +
+    "<b>flat baseline</b> right next to the hierarchy: they use almost the same effort " +
+    "(updates ratio \u2248 <b>" + ratio + "</b>)" +
+    (verdict ? " \u2014 <i>" + verdict + "</i>" : "") + ". " +
+    "The hierarchy gives a <b>small, real</b> benefit, not the dominant one the paper implies. " +
+    "This whole view is a <b>MODELED</b> simulation of the control loop on a toy grid, not a run " +
+    "of the real 27M-parameter HRM network.";
+}
+
+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 _yn(v) { return v === true ? "yes" : v === false ? "no" : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("hrm-grid",     t || (S.n != null ? (S.n + "\u00d7" + S.n + " Latin square") : "\u2014"));
+  _set("hrm-clues",    t || ((S.clues != null && S.emptyStart != null) ? (S.clues + " clues / " + S.emptyStart + " empty") : "\u2014"));
+  _set("hrm-hsolved",  t || (S.hier ? _yn(S.hier.solved) : "\u2014"));
+  _set("hrm-hticks",   t || (S.hier && S.hier.h_ticks_used != null ? String(S.hier.h_ticks_used) : "\u2014"));
+  _set("hrm-hupdates", t || (S.edge && S.edge.hier_updates_total != null ? String(S.edge.hier_updates_total) : "\u2014"));
+  _set("hrm-fsolved",  t || (S.flat ? _yn(S.flat.solved) : "\u2014"));
+  _set("hrm-fupdates", t || (S.edge && S.edge.flat_updates_total != null ? String(S.edge.flat_updates_total) : "\u2014"));
+  _set("hrm-ratio",    t || (S.edge && S.edge.updates_ratio != null ? S.edge.updates_ratio.toFixed(3) : "\u2014"));
+  _set("hrm-verdict",  t || (S.edge && typeof S.edge.verdict === "string"
+    ? (S.edge.verdict.length > 64 ? S.edge.verdict.slice(0, 61) + "\u2026" : S.edge.verdict)
+    : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("hrm-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; _cellMesh = []; _planBar = null; _flatBar = null; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.n = S.hTicks = S.lSteps = S.clues = S.emptyStart = null;
+  S.hier = S.flat = S.edge = S.finalGrid = S.caveat = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/pfield.js

@@ -0,0 +1,565 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/pfield.js — PFIELD (Pressure-Field Stigmergic Multi-Agent
+// Coordination) organ for the holographic frontier ring. Renders the shared
+// constraint-grid ARTIFACT as a lattice of cells whose height/glow encodes the
+// live PRESSURE field: high-violation cells rise as lattice-blue pillars, and
+// as the N pressure-field agents implicitly de-conflict (no messages), the
+// pillars collapse to a flat proof-teal solved plane. A side-by-side HUD sweeps
+// agent counts 2..32 comparing pfield vs sequential vs hierarchical
+// (solve-rate, steps-to-converge, coordination messages), and a decay-ablation
+// readout shows the ~49x pressure runaway when temporal decay is disabled. All
+// numbers come from the live snapshot at /api/killinchu/v1/pfield/coordinate.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is;
+// it is never upgraded.
+//
+// Surface export shape (mirrors grpo.js / goat.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   n_agents, grid, decay, steps, pfield{solved,steps_to_converge,
+//   final_violations,peak_pressure,messages,violation_trajectory[],
+//   pressure_trajectory[]}, baselines{sequential,hierarchical}, sweep[],
+//   ablation{peak_pressure_decay,peak_pressure_no_decay,pressure_runaway_x},
+//   matches_hierarchical
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Pressure-field stigmergic coordination + temporal decay (simulated here,
+//   including the ~49x no-decay pressure runaway):
+//     Rodriguez 2026, "Emergent Coordination in Multi-Agent Systems via
+//     Pressure Fields and Temporal Decay", arXiv:2601.08129 (13 Jan 2026)
+//     https://arxiv.org/abs/2601.08129
+//     full text: https://arxiv.org/html/2601.08129v3
+//
+// HONESTY LABELS: MODELED (deterministic simulation of the pressure-field /
+//   temporal-decay coordination arithmetic; NOT real LLM agents; NO real
+//   message passing; NEVER-CLAIMED-AS a real multi-agent deployment). Read
+//   verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (pressure pillars / artifact grid), violet-blue
+//   0x8a6bff (temporal-decay / ablation trace), proof-teal 0x3af4c8 (solved
+//   cells / pfield accent), greys (degraded / no-live-data). Purple BANNED as
+//   UI/background.
+// 0 RUNTIME CDN. three.js via ctx.THREE (page importmap / vendored).
+// 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    = "pfield";
+const TITLE = "PFIELD · Pressure-Field Stigmergic Coordination (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 pfield organ's rebuilds/faults isolated.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/pfield/coordinate?seed=42&n_agents=8&grid=6&decay=0.8&steps=200";
+
+// data-viz hues — purple BANNED
+const C_PRESS  = 0x5b8dee;  // lattice-blue (pressure pillars / artifact grid)
+const C_SOLVED = 0x3af4c8;  // proof-teal (solved cells / pfield accent)
+const C_DECAY  = 0x8a6bff;  // violet-blue (temporal-decay / ablation trace)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const CELL_GAP   = 1.05;   // world-units between artifact cells
+const MAX_SIDE   = 12;     // cap on grid side length rendered (n x n cells)
+const PILLAR_W   = 0.66;   // cell pillar footprint
+const PILLAR_MAXH = 4.0;   // max pillar height at peak local pressure
+const ABL_LEN    = 6.0;    // world-length of the ablation bar pair along X
+const AGENT_ORBIT = 5.4;   // radius agents orbit the artifact at (visual only)
+const MAX_AGENTS = 32;     // cap on agent motes rendered
+
+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 _cells      = [];                 // Array<THREE.Mesh> — artifact-cell pressure pillars (row-major)
+let _cellSide   = 0;                  // current rendered grid side length
+let _agents     = [];                 // Array<THREE.Mesh> — orbiting agent motes (visual)
+let _ablDecay   = null;               // THREE.Mesh — decay-on peak bar (bounded)
+let _ablNoDecay = null;               // THREE.Mesh — decay-off peak bar (runaway)
+
+// live state
+const S = {
+  label:        null,
+  nAgents:      null,   // n_agents
+  grid:         null,   // grid side length
+  decay:        null,   // decay
+  steps:        null,   // steps
+  solved:       null,   // pfield.solved
+  stepsConv:    null,   // pfield.steps_to_converge
+  finalViol:    null,   // pfield.final_violations
+  peakPress:    null,   // pfield.peak_pressure
+  messages:     null,   // pfield.messages (0 for stigmergic)
+  violTraj:     null,   // pfield.violation_trajectory[]
+  pressTraj:    null,   // pfield.pressure_trajectory[]
+  seqSolved:    null,   // baselines.sequential.solved
+  seqSteps:     null,   // baselines.sequential.steps_to_converge
+  hierSolved:   null,   // baselines.hierarchical.solved
+  hierSteps:    null,   // baselines.hierarchical.steps_to_converge
+  hierMsgs:     null,   // baselines.hierarchical.messages
+  sweep:        null,   // sweep[]
+  ablDecayPk:   null,   // ablation.peak_pressure_decay
+  ablNoDecayPk: null,   // ablation.peak_pressure_no_decay
+  runawayX:     null,   // ablation.pressure_runaway_x
+  matchesHier:  null,   // matches_hierarchical
+  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, 11, 19);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 1, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildCells(6);          // pre-build a default 6x6 lattice; rebuilt on live data
+  _buildAgents();
+  _buildAblation();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onPfield, { badge: _badge, onState: (m) => { S.state = m.state; _updateScene(); _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;
+}
+
+// The shared constraint-grid ARTIFACT: an n x n lattice of unit-footprint
+// pillars. Each pillar's height/glow encodes that cell's live pressure. Rebuilt
+// only when the grid side length changes (rare); heights/colours are toggled
+// in-place per poll otherwise (no per-poll geometry churn).
+function _buildCells(side) {
+  const THREE = _THREE;
+  _disposeCells();
+  _cellSide = Math.max(1, Math.min(side, MAX_SIDE));
+  const off = (_cellSide - 1) / 2;
+  const geo = new THREE.BoxGeometry(PILLAR_W, 1, PILLAR_W); // unit-height; scaled on update
+  for (let r = 0; r < _cellSide; r++) {
+    for (let c = 0; c < _cellSide; c++) {
+      const mesh = new THREE.Mesh(
+        geo,
+        new THREE.MeshStandardMaterial({ color: C_PRESS, emissive: C_PRESS, emissiveIntensity: 0.25, transparent: true, opacity: 0.85 }),
+      );
+      mesh.position.set((c - off) * CELL_GAP, 0.05, (r - off) * CELL_GAP);
+      mesh.scale.y = 0.1;
+      _group.add(mesh);
+      _cells.push(mesh);
+    }
+  }
+}
+
+// Orbiting agent motes — a purely-visual ring of N points circling the artifact
+// to represent the N coordinating agents. They carry NO data (the endpoint
+// transmits aggregates only); their count tracks n_agents.
+function _buildAgents() {
+  const THREE = _THREE;
+  const geo = new THREE.SphereGeometry(0.14, 10, 10);
+  for (let i = 0; i < MAX_AGENTS; i++) {
+    const m = new THREE.Mesh(
+      geo,
+      new THREE.MeshStandardMaterial({ color: C_SOLVED, emissive: C_SOLVED, emissiveIntensity: 0.5, transparent: true, opacity: 0.0 }),
+    );
+    m.visible = false;
+    _group.add(m);
+    _agents.push(m);
+  }
+}
+
+// Decay ablation: two bars side by side above the artifact — decay-ON peak
+// pressure (proof-teal, bounded) vs decay-OFF peak pressure (violet-blue,
+// runaway). Their height ratio IS the pressure_runaway_x figure.
+function _buildAblation() {
+  const THREE = _THREE;
+  const geo = new THREE.BoxGeometry(0.7, 1, 0.7);
+
+  _ablDecay = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_SOLVED, emissive: C_SOLVED, emissiveIntensity: 0.4, transparent: true, opacity: 0.0 }),
+  );
+  _ablDecay.position.set(-1.0, 0.001, -((MAX_SIDE / 2) * CELL_GAP + 2.2));
+  _group.add(_ablDecay);
+
+  _ablNoDecay = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_DECAY, emissive: C_DECAY, emissiveIntensity: 0.4, transparent: true, opacity: 0.0 }),
+  );
+  _ablNoDecay.position.set(1.0, 0.001, -((MAX_SIDE / 2) * CELL_GAP + 2.2));
+  _group.add(_ablNoDecay);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onPfield(j) {
+  // read honesty label VERBATIM — never upgrade. This module places the label
+  // at TOP LEVEL of the JSON (j.label); also tolerate a nested payload.label to
+  // match either module shape.
+  const rawLabel = (j && (j.label != null ? j.label : (j.payload && j.payload.label))) || "MODELED";
+  S.label   = String(rawLabel).toUpperCase();
+
+  S.nAgents = typeof j.n_agents === "number" ? j.n_agents : null;
+  S.grid    = typeof j.grid     === "number" ? j.grid     : null;
+  S.decay   = typeof j.decay    === "number" ? j.decay    : null;
+  S.steps   = typeof j.steps    === "number" ? j.steps    : null;
+
+  const pf = j.pfield || {};
+  S.solved    = typeof pf.solved            === "boolean" ? pf.solved            : null;
+  S.stepsConv = typeof pf.steps_to_converge === "number"  ? pf.steps_to_converge : null;
+  S.finalViol = typeof pf.final_violations  === "number"  ? pf.final_violations  : null;
+  S.peakPress = typeof pf.peak_pressure     === "number"  ? pf.peak_pressure     : null;
+  S.messages  = typeof pf.messages          === "number"  ? pf.messages          : null;
+  S.violTraj  = Array.isArray(pf.violation_trajectory) ? pf.violation_trajectory : null;
+  S.pressTraj = Array.isArray(pf.pressure_trajectory)  ? pf.pressure_trajectory  : null;
+
+  const bl = j.baselines || {};
+  const seq = bl.sequential || {};
+  const hier = bl.hierarchical || {};
+  S.seqSolved  = typeof seq.solved            === "boolean" ? seq.solved            : null;
+  S.seqSteps   = typeof seq.steps_to_converge === "number"  ? seq.steps_to_converge : null;
+  S.hierSolved = typeof hier.solved            === "boolean" ? hier.solved            : null;
+  S.hierSteps  = typeof hier.steps_to_converge === "number"  ? hier.steps_to_converge : null;
+  S.hierMsgs   = typeof hier.messages          === "number"  ? hier.messages          : null;
+
+  S.sweep = Array.isArray(j.sweep) ? j.sweep : null;
+
+  const ab = j.ablation || {};
+  S.ablDecayPk   = typeof ab.peak_pressure_decay    === "number" ? ab.peak_pressure_decay    : null;
+  S.ablNoDecayPk = typeof ab.peak_pressure_no_decay === "number" ? ab.peak_pressure_no_decay : null;
+  S.runawayX     = typeof ab.pressure_runaway_x     === "number" ? ab.pressure_runaway_x     : null;
+
+  S.matchesHier = typeof j.matches_hierarchical === "boolean" ? j.matches_hierarchical : null;
+
+  // rebuild the artifact lattice if the grid side length changed
+  if (S.grid != null && S.grid !== _cellSide) _buildCells(S.grid);
+
+  _updateScene();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the artifact lattice + agents + ablation bars
+// =============================================================================
+function _updateScene() {
+  const live = S.state === "live";
+
+  // ARTIFACT lattice: pillar height/colour encodes the pressure landscape.
+  // The endpoint transmits aggregate traces (not the full per-cell field), so
+  // we render an honest proxy: distribute the current total pressure /
+  // remaining violations across the lattice as a decaying radial gradient, and
+  // flip cells to the solved colour once the run has converged.
+  const nCells = _cells.length;
+  const totalPeak = live && S.peakPress != null ? S.peakPress : 0;
+  const finalViol = live && S.finalViol != null ? S.finalViol : null;
+  const solved = live && S.solved === true;
+
+  for (let i = 0; i < nCells; i++) {
+    const mesh = _cells[i];
+    if (!live) {
+      mesh.material.color.setHex(C_DIM);
+      mesh.material.emissive.setHex(C_DIM);
+      mesh.material.emissiveIntensity = 0.06;
+      mesh.material.opacity = 0.3;
+      mesh.scale.y = 0.1;
+      mesh.position.y = 0.05;
+      continue;
+    }
+    // radial pressure proxy: cells nearer the centre carry more residual
+    // pressure (deterministic layout, honest aggregate — not a faked per-cell
+    // reading). When solved, all pillars flatten to the proof-teal plane.
+    const side = _cellSide || 1;
+    const r = Math.floor(i / side), c = i % side;
+    const off = (side - 1) / 2;
+    const dist = Math.sqrt((r - off) * (r - off) + (c - off) * (c - off)) / (Math.max(1, off) * 1.4142);
+    const radial = 1.0 - Math.min(1, dist);         // 1 at centre, 0 at corners
+    const pressNorm = totalPeak > 0 ? Math.min(1, totalPeak / (nCells * 8)) : 0;
+    let h;
+    if (solved) {
+      h = 0.12;
+    } else {
+      h = 0.12 + radial * pressNorm * PILLAR_MAXH;
+    }
+    mesh.scale.y = Math.max(0.08, h);
+    mesh.position.y = mesh.scale.y / 2;
+
+    const color = solved ? C_SOLVED : C_PRESS;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = solved ? 0.45 : 0.2 + 0.5 * radial * pressNorm;
+    mesh.material.opacity = 0.9;
+  }
+
+  // agent motes: show n_agents of them orbiting; teal when solved, blue while
+  // still coordinating; grey/hidden when not live.
+  const na = live && S.nAgents != null ? Math.min(S.nAgents, MAX_AGENTS) : 0;
+  for (let i = 0; i < MAX_AGENTS; i++) {
+    const m = _agents[i];
+    const on = i < na;
+    m.visible = on;
+    if (!on) { m.material.opacity = 0.0; continue; }
+    const color = solved ? C_SOLVED : C_PRESS;
+    m.material.color.setHex(color);
+    m.material.emissive.setHex(color);
+    m.material.opacity = 0.9;
+  }
+
+  // ablation bars: decay-on (bounded) vs decay-off (runaway). Normalise both
+  // against the larger (no-decay) peak so the runaway bar towers over the
+  // decayed one — the height ratio IS pressure_runaway_x.
+  const on = live && S.ablDecayPk != null && S.ablNoDecayPk != null;
+  const denom = on ? Math.max(S.ablNoDecayPk, 1e-6) : 1;
+  if (_ablDecay) {
+    _ablDecay.material.opacity = on ? 0.92 : 0.0;
+    const hD = on ? Math.max(0.05, (S.ablDecayPk / denom) * 6.5) : 0.05;
+    _ablDecay.scale.y = hD; _ablDecay.position.y = hD / 2;
+    const c = live ? C_SOLVED : C_DIM;
+    _ablDecay.material.color.setHex(c); _ablDecay.material.emissive.setHex(c);
+  }
+  if (_ablNoDecay) {
+    _ablNoDecay.material.opacity = on ? 0.92 : 0.0;
+    const hN = on ? Math.max(0.05, (S.ablNoDecayPk / denom) * 6.5) : 0.05;
+    _ablNoDecay.scale.y = hN; _ablNoDecay.position.y = hN / 2;
+    const c = live ? C_DECAY : C_DIM;
+    _ablNoDecay.material.color.setHex(c); _ablNoDecay.material.emissive.setHex(c);
+  }
+
+  _finalViolUnused(finalViol);
+}
+
+// finalViol is surfaced in the HUD; referenced here only to keep the value in
+// scope for future per-cell rendering without triggering an unused warning.
+function _finalViolUnused(_v) { return _v; }
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.10;
+
+  // orbit the visible agent motes around the artifact
+  const na = _agents.length;
+  for (let i = 0; i < na; i++) {
+    const m = _agents[i];
+    if (!m.visible) continue;
+    const ang = (i / Math.max(1, na)) * Math.PI * 2 + t * 0.0006;
+    m.position.set(Math.cos(ang) * AGENT_ORBIT, 1.6 + 0.4 * Math.sin(t * 0.002 + i), Math.sin(ang) * AGENT_ORBIT);
+  }
+  if (_ablNoDecay && _ablNoDecay.material.opacity > 0) _ablNoDecay.rotation.y += 0.01;
+  if (_ablDecay && _ablDecay.material.opacity > 0) _ablDecay.rotation.y += 0.01;
+}
+
+// =============================================================================
+// 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 =
+    'Instead of a planner messaging executors, N agents coordinate <b>implicitly</b> through a ' +
+    'shared constraint-grid artifact: each agent reads a local <b>pressure</b> (constraint-violation ' +
+    'count), takes the pressure-reducing edit, and a <b>temporal-decay</b> schedule keeps stale ' +
+    'pressure from locking the system in \u2014 <b>zero inter-agent messages</b> (stigmergy). Shown ' +
+    'against sequential + hierarchical baselines. Honesty label <b>MODELED</b> (deterministic ' +
+    'simulation; NOT real agents). 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 = "pressure-field coordination";
+  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:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("pf-agents",   "n_agents \u00d7 grid"));
+  grid.appendChild(kpiRow("pf-decay",    "temporal decay (per step)"));
+  grid.appendChild(kpiRow("pf-steps",    "pfield steps-to-converge \u2014 MODELED"));
+  grid.appendChild(kpiRow("pf-msgs",     "pfield inter-agent messages"));
+  grid.appendChild(kpiRow("pf-seq",      "sequential steps-to-converge \u2014 MODELED"));
+  grid.appendChild(kpiRow("pf-hier",     "hierarchical steps / messages \u2014 MODELED"));
+  grid.appendChild(kpiRow("pf-match",    "pfield matches hierarchical?"));
+  grid.appendChild(kpiRow("pf-runaway",  "no-decay pressure runaway \u2014 MODELED"));
+  grid.appendChild(kpiRow("pf-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 = "Rodriguez 2026 \u00b7 Pressure Fields + Temporal Decay \u00b7 arXiv:2601.08129. 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 = "pf-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 na  = S.nAgents  != null ? String(S.nAgents) : "loading\u2026";
+  const pfs = S.stepsConv != null ? String(S.stepsConv) : "loading\u2026";
+  const hms = S.hierMsgs != null ? String(S.hierMsgs) : "loading\u2026";
+  const rw  = S.runawayX != null ? S.runawayX.toFixed(0) + "x" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Getting many AI agents to work together usually needs a <i>boss</i> agent " +
+    "that hands out tasks and collects results \u2014 lots of back-and-forth messages that pile up as you add " +
+    "workers. This approach skips the boss entirely. All <b>" + na + " agents</b> scribble on one shared " +
+    "worksheet; wherever the worksheet looks wrong, \u201cpressure\u201d builds up and naturally pulls the nearest " +
+    "agent to fix it \u2014 like ants leaving scent trails (called <b>stigmergy</b>). No agent ever messages " +
+    "another. Here it finishes in about <b>" + pfs + " rounds with zero messages</b>, matching the boss-based " +
+    "method that needed roughly <b>" + hms + " messages</b>. One catch: the pressure has to <b>fade over time</b>, " +
+    "or it snowballs \u2014 turning decay off makes the pressure blow up about <b>" + rw + "</b>. This view is a " +
+    "<b>MODELED</b> deterministic simulation of that coordination math, not a run of real AI agents.";
+}
+
+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("pf-agents",  t || (S.nAgents != null && S.grid != null ? (S.nAgents + " \u00d7 " + S.grid + "\u00d7" + S.grid) : "\u2014"));
+  _set("pf-decay",   t || fx(S.decay, 3));
+  _set("pf-steps",   t || (S.stepsConv != null ? (S.stepsConv + (S.solved ? " (solved)" : "")) : "\u2014"));
+  _set("pf-msgs",    t || (S.messages != null ? String(S.messages) : "\u2014"));
+  _set("pf-seq",     t || (S.seqSteps != null ? (S.seqSteps + (S.seqSolved ? " (solved)" : "")) : "\u2014"));
+  _set("pf-hier",    t || (S.hierSteps != null ? (S.hierSteps + " / " + (S.hierMsgs != null ? S.hierMsgs + " msgs" : "\u2014")) : "\u2014"));
+  _set("pf-match",   t || (S.matchesHier === true ? "yes (\u2265 hierarchical, 0 msgs)" : S.matchesHier === false ? "no" : "\u2014"));
+  _set("pf-runaway", t || (S.runawayX != null ? (S.runawayX.toFixed(1) + "\u00d7 without decay") : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("pf-label",   t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+function _disposeCells() {
+  const THREE = _THREE;
+  if (_cells && _cells.length && _group) {
+    _cells.forEach((m) => {
+      try {
+        if (m.geometry && m.geometry.dispose) m.geometry.dispose();
+        if (m.material && m.material.dispose) m.material.dispose();
+        _group.remove(m);
+      } catch (_) {}
+    });
+  }
+  _cells = [];
+  void THREE;
+}
+
+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; _cells = []; _cellSide = 0; _agents = [];
+  _ablDecay = null; _ablNoDecay = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.nAgents = S.grid = S.decay = S.steps = null;
+  S.solved = S.stepsConv = S.finalViol = S.peakPress = S.messages = null;
+  S.violTraj = S.pressTraj = null;
+  S.seqSolved = S.seqSteps = S.hierSolved = S.hierSteps = S.hierMsgs = null;
+  S.sweep = S.ablDecayPk = S.ablNoDecayPk = S.runawayX = S.matchesHier = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/qhall.js

@@ -0,0 +1,490 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/qhall.js — QUANTUM-INSPIRED TENSOR-NETWORK HALLUCINATION-UNCERTAINTY
+// organ for the holographic frontier ring.
+//
+// Renders a 3D constellation of candidate LLM generations, encoded as low-bond-dimension
+// matrix-product-state (MPS) vectors and grouped into semantic-equivalence clusters, driven
+// by a live snapshot from /api/killinchu/v1/qhall/quantify. Each generation is a node; nodes
+// in the same semantic cluster share a colour and orbit a common cluster centroid. A HUD
+// tracks the semantic entropy (aleatoric-uncertainty score) and whether it crosses the
+// oversight threshold — the "entropy maximization for human-review flagging" behaviour.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is; never upgraded.
+//
+// IMPORTANT — QUANTUM-INSPIRED, NOT A REAL QUANTUM COMPUTER:
+//   "Quantum tensor network" here is the mathematical INSPIRATION (low-rank MPS math from
+//   quantum many-body physics), simulated ENTIRELY on a classical CPU. There is NO quantum
+//   hardware, NO quantum circuit, and NO real LLM behind this organ — the candidate answers
+//   and their sequence log-probabilities are synthetic toy data. This is stated plainly in
+//   the "what this means" copy and echoed in the endpoint's own JSON payload.
+//
+// Surface export shape (mirrors interpretability.js / qec.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   n_generations         — candidate generations for the fixed prompt
+//   bond_dim              — MPS bond dimension χ (low-rank truncation)
+//   n_clusters            — semantic-equivalence classes found
+//   cluster_sizes         — member counts per class
+//   semantic_entropy      — aleatoric-uncertainty score (nats)
+//   normalized_entropy    — semantic_entropy / ln(n)  (0..1)
+//   threshold             — oversight threshold (nats)
+//   flag_for_review       — bool (entropy-maximization human-review flag)
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Vipulanandan, Premaratne & Sarkar (2026) "Semantic Uncertainty Quantification of
+//     Hallucinations in LLMs: A Quantum Tensor Network Based Method". arXiv:2601.20026
+//     (ICLR 2026; 116 experiments, 8 model families).
+//     https://arxiv.org/abs/2601.20026
+//
+// HONESTY LABELS: MODELED (simulation of the METHOD on synthetic toy data; quantum-INSPIRED
+//   classical MPS stand-in, NO real quantum hardware, NO real LLM). Read verbatim from JSON.
+// COLOURS: lattice-blue 0x5b8dee (consistent / dominant cluster nodes), violet-blue 0x8a6bff
+//   (scattered / contradictory cluster nodes — data-viz only), proof-teal 0x3af4c8 (entropy
+//   HUD accent), greys for dim/idle. Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 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    = "qhall";
+const TITLE = "Quantum-Inspired Tensor-Network Hallucination Uncertainty (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the qhall organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/qhall/quantify?seed=42&n_generations=8&bond_dim=4&threshold=0.9";
+
+// data-viz hues — purple BANNED
+const C_NODE   = 0x5b8dee;  // lattice-blue (consistent / dominant-cluster generation)
+const C_SCAT   = 0x8a6bff;  // violet-blue (scattered / minority-cluster generation — data-viz only)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data / idle node)
+const C_ACCENT = 0x3af4c8;  // proof-teal accent (entropy HUD ring)
+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 _nodes = [];        // Array<THREE.Mesh> — one per candidate generation
+let _links = null;      // THREE.LineSegments — intra-cluster links
+let _ring = null;       // THREE.Mesh — entropy HUD ring above the constellation
+const _lastN = { n: 0 };// last-built node count, so we only rebuild on change
+
+// max constellation we'll ever build (matches endpoint answer-bank cap)
+const _MAX_NODES = 8;
+const _pulse = new Float32Array(_MAX_NODES);
+
+// live state
+const S = {
+  label:      null,
+  n:          null,   // n_generations
+  bondDim:    null,   // bond_dim
+  nClusters:  null,   // n_clusters
+  sizes:      null,   // cluster_sizes[]
+  entropy:    null,   // semantic_entropy
+  normEnt:    null,   // normalized_entropy
+  threshold:  null,   // threshold
+  flag:       null,   // flag_for_review
+  clusterOf:  [],     // per-node cluster index (from generations[])
+  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, 8, 20);
+  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();
+  _buildConstellation(8);   // default 8-node constellation; rebuilt on live data if n differs
+  _buildEntropyRing();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onQuantify, { 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);
+}
+
+// Build (or rebuild) an n-node constellation of candidate generations, laid out on a
+// ring. Cluster membership (colour + intra-cluster links) is applied later from live data.
+function _buildConstellation(n) {
+  const THREE = _THREE;
+  n = Math.max(2, Math.min(n | 0, _MAX_NODES));
+  if (_lastN.n === n && _nodes.length) return; // already built at this size
+  _lastN.n = n;
+
+  _disposeConstellation();
+
+  const radius = 5.2;
+  const y = 1.4;
+
+  const geo = new THREE.SphereGeometry(0.42, 16, 12);
+  const mat0 = new THREE.MeshStandardMaterial({ color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.15, metalness: 0.25, roughness: 0.55 });
+
+  _nodes = [];
+  for (let i = 0; i < n; i++) {
+    const a = (i / n) * Math.PI * 2;
+    const x = Math.cos(a) * radius;
+    const z = Math.sin(a) * radius;
+    const mesh = new THREE.Mesh(geo, mat0.clone());
+    mesh.position.set(x, y, z);
+    mesh.userData.home = new THREE.Vector3(x, y, z);
+    _group.add(mesh);
+    _nodes.push(mesh);
+  }
+}
+
+function _disposeConstellation() {
+  if (_nodes[0] && _nodes[0].geometry) _nodes[0].geometry.dispose(); // shared geometry
+  _nodes.forEach((m) => {
+    _group.remove(m);
+    if (m.material && m.material.dispose) m.material.dispose();
+  });
+  if (_links) {
+    _group.remove(_links);
+    if (_links.geometry) _links.geometry.dispose();
+    if (_links.material) _links.material.dispose();
+    _links = null;
+  }
+  _nodes = [];
+}
+
+function _buildEntropyRing() {
+  const THREE = _THREE;
+  _ring = new THREE.Mesh(
+    new THREE.TorusGeometry(2.0, 0.035, 10, 64),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.4, transparent: true, opacity: 0.5 }),
+  );
+  _ring.position.set(0, 5.6, 0);
+  _ring.rotation.x = Math.PI / 2;
+  _group.add(_ring);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onQuantify(j) {
+  // Read honesty label VERBATIM — never upgrade. Handle top-level 'label' OR a nested
+  // 'payload.label' so we match this module's own shape (top-level) AND any wrapper.
+  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.n          = typeof p.n_generations      === "number" ? p.n_generations      : null;
+  S.bondDim    = typeof p.bond_dim           === "number" ? p.bond_dim           : null;
+  S.nClusters  = typeof p.n_clusters         === "number" ? p.n_clusters         : null;
+  S.sizes      = Array.isArray(p.cluster_sizes) ? p.cluster_sizes                : null;
+  S.entropy    = typeof p.semantic_entropy   === "number" ? p.semantic_entropy   : null;
+  S.normEnt    = typeof p.normalized_entropy === "number" ? p.normalized_entropy : null;
+  S.threshold  = typeof p.threshold          === "number" ? p.threshold          : null;
+  S.flag       = typeof p.flag_for_review    === "boolean" ? p.flag_for_review   : null;
+
+  // per-node cluster assignment from generations[]
+  S.clusterOf = [];
+  if (Array.isArray(p.generations)) {
+    p.generations.forEach((g) => {
+      S.clusterOf.push(typeof g.cluster === "number" ? g.cluster : 0);
+    });
+  }
+
+  if (S.n) _buildConstellation(S.n);
+  _updateConstellation();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — colours nodes by cluster, links intra-cluster members
+// =============================================================================
+function _updateConstellation() {
+  const THREE = _THREE;
+  const live = S.state === "live";
+
+  // dominant cluster (largest) is drawn lattice-blue (consistent); minority clusters are
+  // violet-blue (scattered / contradictory — data-viz only).
+  let dominant = 0;
+  if (Array.isArray(S.sizes) && S.sizes.length) {
+    let best = -1;
+    S.sizes.forEach((sz, ci) => { if (sz > best) { best = sz; dominant = ci; } });
+  }
+
+  _nodes.forEach((mesh, i) => {
+    if (live && S.clusterOf.length) {
+      const ci = i < S.clusterOf.length ? S.clusterOf[i] : 0;
+      const col = ci === dominant ? C_NODE : C_SCAT;
+      mesh.material.color.setHex(col);
+      mesh.material.emissive.setHex(col);
+      mesh.material.emissiveIntensity = 0.35;
+      _pulse[i] = 60;
+    } else {
+      mesh.material.color.setHex(C_DIM);
+      mesh.material.emissive.setHex(C_DIM);
+      mesh.material.emissiveIntensity = 0.12;
+    }
+  });
+
+  // intra-cluster links: connect every pair of nodes sharing a cluster.
+  if (_links) {
+    _group.remove(_links);
+    if (_links.geometry) _links.geometry.dispose();
+    if (_links.material) _links.material.dispose();
+    _links = null;
+  }
+  if (live && S.clusterOf.length) {
+    const pts = [];
+    for (let a = 0; a < _nodes.length; a++) {
+      for (let b = a + 1; b < _nodes.length; b++) {
+        if (S.clusterOf[a] != null && S.clusterOf[a] === S.clusterOf[b]) {
+          pts.push(_nodes[a].position.clone(), _nodes[b].position.clone());
+        }
+      }
+    }
+    if (pts.length) {
+      const lg = new THREE.BufferGeometry().setFromPoints(pts);
+      _links = new THREE.LineSegments(lg, new THREE.LineBasicMaterial({ color: C_NODE, transparent: true, opacity: 0.3 }));
+      _group.add(_links);
+    }
+  }
+
+  if (_ring) {
+    // ring brightness/scale scales with normalized entropy: HIGH entropy (scattered,
+    // flagged for review) burns brighter; LOW entropy (consistent) stays calm.
+    const norm = S.normEnt != null ? Math.max(0, Math.min(1, S.normEnt)) : 0;
+    const flagged = S.flag === true;
+    const rcol = live ? (flagged ? C_SCAT : C_ACCENT) : C_DIM;
+    _ring.material.color.setHex(rcol);
+    _ring.material.emissive.setHex(rcol);
+    _ring.material.emissiveIntensity = live ? 0.2 + 0.7 * norm : 0.12;
+    _ring.material.opacity = live ? 0.55 : 0.2;
+    _ring.scale.setScalar(live ? (0.7 + 0.6 * norm) : 0.8);
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.0001) * 0.15;
+  if (_ring) { _ring.rotation.z += 0.004; }
+
+  const live = S.state === "live";
+  _nodes.forEach((mesh, i) => {
+    if (_pulse[i] > 0) {
+      _pulse[i] -= 1;
+      const f = _pulse[i] / 60;
+      mesh.material.emissiveIntensity = Math.max(mesh.material.emissiveIntensity, 0.2 + 0.8 * f);
+    }
+    // gentle bob so consistent vs scattered clusters read as "living" data
+    if (mesh.userData.home) {
+      mesh.position.y = mesh.userData.home.y + (live ? Math.sin(t * 0.0012 + i) * 0.12 : 0);
+    }
+  });
+}
+
+// =============================================================================
+// 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 =
+    'Several candidate answers for one prompt are encoded as low-rank ' +
+    '<b>matrix-product-state (MPS) tensor vectors</b>, clustered into ' +
+    '<b>semantic-equivalence classes</b>, and scored by the <b>entropy</b> of the ' +
+    'cluster distribution. Low entropy \u2192 the answers agree (confident); high ' +
+    'entropy \u2192 they contradict each other and the prompt is <b>flagged for human ' +
+    'review</b>. Honesty label <b>MODELED</b> \u2014 <b>quantum-INSPIRED</b> (a classical ' +
+    'tensor-network stand-in), <b>not</b> a real quantum computer and not a real 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:#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 = "qhall \u00b7 semantic-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:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("qh-n",      "candidate generations"));
+  grid.appendChild(kpiRow("qh-bond",   "MPS bond dimension \u03c7"));
+  grid.appendChild(kpiRow("qh-clus",   "semantic clusters"));
+  grid.appendChild(kpiRow("qh-sizes",  "cluster sizes"));
+  grid.appendChild(kpiRow("qh-ent",    "semantic entropy (nats) \u2014 MODELED"));
+  grid.appendChild(kpiRow("qh-norm",   "normalized entropy (0\u20131)"));
+  grid.appendChild(kpiRow("qh-thr",    "oversight threshold (nats)"));
+  grid.appendChild(kpiRow("qh-flag",   "flag for human review"));
+  grid.appendChild(kpiRow("qh-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 = "Vipulanandan, Premaratne & Sarkar arXiv:2601.20026 (ICLR 2026) \u00b7 quantum-INSPIRED classical MPS stand-in, no real quantum hardware, no real LLM. 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 = "qhall-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 n    = S.n != null ? String(S.n) : "loading\u2026";
+  const cl   = S.nClusters != null ? String(S.nClusters) : "loading\u2026";
+  const ent  = S.entropy != null ? S.entropy.toFixed(3) : "loading\u2026";
+  const verdict = S.flag == null
+    ? "loading\u2026"
+    : (S.flag ? "FLAGGED for a human to double-check" : "confident \u2014 no review needed");
+  pd.innerHTML =
+    "<b>What this means:</b> We ask the model the same question and collect <b>" + n + "</b> " +
+    "candidate answers. Each answer is turned into a compact math fingerprint (a " +
+    "<b>tensor-network / MPS vector</b>) and answers that mean the same thing are grouped " +
+    "together \u2014 here into <b>" + cl + "</b> distinct meaning-groups. If almost all answers " +
+    "land in one group, the model is confident; if they scatter across many contradictory " +
+    "groups, that's a warning sign of a possible <b>hallucination</b>. We measure that scatter " +
+    "with <b>entropy = " + ent + "</b>: right now this prompt is <b>" + verdict + "</b>. " +
+    "<br><br><b>Important honesty note:</b> this organ is <b>quantum-INSPIRED</b>, not a real " +
+    "quantum computer. The tensor-network math borrows ideas from quantum physics, but it runs " +
+    "entirely on an ordinary classical processor \u2014 there is <b>no quantum hardware</b> and " +
+    "<b>no quantum circuit</b> involved. It is also <b>not</b> a real language model: the answers " +
+    "and their probabilities are <b>synthetic toy data</b> for demonstration. Everything shown is " +
+    "a <b>MODELED</b> simulation of the method (Vipulanandan et al., ICLR 2026), not a live readout.";
+}
+
+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("qh-n",     t || (S.n != null ? String(S.n) : "\u2014"));
+  _set("qh-bond",  t || (S.bondDim != null ? String(S.bondDim) : "\u2014"));
+  _set("qh-clus",  t || (S.nClusters != null ? String(S.nClusters) : "\u2014"));
+  _set("qh-sizes", t || (Array.isArray(S.sizes) ? "[" + S.sizes.join(", ") + "]" : "\u2014"));
+  _set("qh-ent",   t || fx(S.entropy, 3));
+  _set("qh-norm",  t || fx(S.normEnt, 3));
+  _set("qh-thr",   t || fx(S.threshold, 3));
+  _set("qh-flag",  t || (S.flag == null ? "\u2014" : (S.flag ? "FLAG \u2014 send to human review" : "clear \u2014 high confidence")));
+  // honesty label verbatim — never upgraded
+  _set("qh-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;
+  _nodes = []; _links = null; _ring = null;
+  _lastN.n = 0;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.n = S.bondDim = S.nClusters = S.sizes = null;
+  S.entropy = S.normEnt = S.threshold = S.flag = null;
+  S.clusterOf = [];
+  S.state = "init";
+  _pulse.fill(0);
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };