Align Atlas with canonical roster and add brain trust lens

Fix stale 67-surface coverage denominator by reconciling against szl3d_holographic.SURFACES; include registry digest and explicit UNSPECIFIED labels; add read-only brain health/gaps probe, adaptive 100+ node layout, module alias validation, and regression tests.

static/3d/surfaces/atlas.js

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
 //
-// surfaces/atlas.js — THE ATLAS (SZL, Wave 27, the 68th surface: the unifying front door).
+// surfaces/atlas.js — THE ATLAS (the unifying, registry-aligned front door).
 //
-// A single holographic overview that shows the WHOLE 67-surface holographic estate as ONE
+// A single holographic overview that shows the WHOLE canonical holographic registry as ONE
 // organism, mapped by the Flower Brain's 8 real clusters (the ecosystem's own taxonomy). The
 // still, luminous CENTER is the KERNEL PISTIL — the machine-proven locked-8
 // {F1,F4,F7,F11,F12,F18,F19,F22} (lutar-lean kernel c7c0ba17) — the immutable heart that never
 // grows. Eight labeled cluster regions radiate out at 45° intervals: PROVEN CORE, VERIFIED,
-// EXPERIMENTAL, UNIFIED, OUROBOROS, SURFACES (the big one, 58), MEMORY & PROVENANCE (9), and
+// EXPERIMENTAL, UNIFIED, OUROBOROS, SURFACES, MEMORY & PROVENANCE, and
 // CONJECTURES (GRAY, never green). Each cluster holds its member surfaces as nodes; the kernel
 // clusters carry the flower's kernel objects instead of surfaces. Hover a node -> the surface
 // title + its HONEST label (MODELED / STRUCTURAL-ONLY / ROADMAP / MEASURED — rendered by the
@@ -20,11 +20,11 @@
 // taxonomy source is the Flower Brain (szl_kc_flower.py). The LAYOUT is MODELED — a
 // deterministic, honest drawing read VERBATIM from /api/a11oy/v1/atlas/{map,organism}. The
 // honesty label "MODELED" is shown as-is and is never upgraded. Unification by CARTOGRAPHY:
-// this gives the flat 67-tab wall a spine without removing a single surface.
+// this gives the evolving tab wall a spine without removing a single surface.
 //
 // HARD INVARIANTS (Doctrine v11):
 //   * clusters = EXACTLY 8. locked-core = EXACTLY 8 (the pistil never grows).
-//   * coverage 1.0 — every one of the 67 surfaces is classified into exactly one cluster.
+//   * coverage is measured against szl3d_holographic.SURFACES; denominator + digest are shown.
 //   * CONJECTURE cluster renders GREY (0x5a6570), visibly dim, NEVER green.
 //   * honest label mix rendered by real label (MODELED / STRUCTURAL-ONLY / ROADMAP / MEASURED),
 //     not painted uniform.
@@ -43,6 +43,8 @@ const TITLE = "Atlas";
 // Live endpoints — same convention as loopforge.js (same-origin a11oy namespace).
 const EP_MAP      = "/api/a11oy/v1/atlas/map";
 const EP_ORGANISM = "/api/a11oy/v1/atlas/organism";
+const EP_BRAIN_HEALTH = "/api/a11oy/v1/brain/health?query=evidence-bound%20brain%20atlas&k=12";
+const EP_BRAIN_GAPS = "/api/a11oy/v1/brain/gaps?query=evidence-bound%20brain%20atlas&k=12";
 
 // ---- Colour palette. We render the estate honestly using ONLY teal / lattice-blue / cyan-blue /
 // gold / greys / black. The backend's cluster hue field carries a bluish tone upstream for the
@@ -81,10 +83,12 @@ const LABEL_COLOR = {
   "STRUCTURAL-ONLY": C_DIM,     // structural-only — dim grey-blue, no proof claim
   "ROADMAP":         C_GOLD,    // roadmap — gold, not-yet-built
   "MEASURED":        C_LOCKED,  // measured — proof-teal (the one truly measured surface)
+  "SIMULATED":       C_GOLD,    // simulated — visible but not live-world evidence
+  "UNSPECIFIED":     C_DIM,     // no maturity claim in the canonical registry
 };
 function _labelColor(lbl) {
-  const t = String(lbl || "MODELED").toUpperCase();
-  return LABEL_COLOR[t] != null ? LABEL_COLOR[t] : C_VERIF;
+  const t = String(lbl || "UNSPECIFIED").toUpperCase();
+  return LABEL_COLOR[t] != null ? LABEL_COLOR[t] : C_DIM;
 }
 
 // Geometry constants.
@@ -117,13 +121,17 @@ const S = {
   crossLinks: [],              // from /organism
   lfFlow: null,                // Loop-Forge flow overlay
   clustersTotal: null,
-  surfaceCount: null,          // 67
+  surfaceCount: null,
   totalClassified: null,
   coverage: null,
+  registry: null,
   lockedCoreCount: null,
   conjectureGray: null,
   everyOnce: null,
   labelMix: {},                // overall honest label mix
+  brainHealth: null,
+  brainGaps: null,
+  brainProbeState: "init",
   built: false,
 };
 
@@ -158,6 +166,10 @@ function mount(ctx) {
   _polls.push(ctx.live.poll(EP_ORGANISM, 20000, _onOrganism, {
     onState: (m) => { S.state = m.state; _paintOverlay(); },
   }));
+  _polls.push(ctx.live.poll(EP_BRAIN_HEALTH, 30000, _onBrainHealth, {
+    onState: (m) => { S.brainProbeState = m.state; _paintOverlay(); },
+  }));
+  _polls.push(ctx.live.poll(EP_BRAIN_GAPS, 45000, _onBrainGaps, {}));
 
   // pointer hover/click for node picking + surface deep-linking.
   _domEl = (_stage.renderer && _stage.renderer.domElement) || null;
@@ -192,6 +204,7 @@ function _onMap(j) {
   S.surfaceCount = p.surface_count != null ? p.surface_count : null;
   S.totalClassified = p.total_classified != null ? p.total_classified : null;
   S.coverage = p.coverage != null ? p.coverage : null;
+  S.registry = p.registry || null;
   S.lockedCoreCount = p.locked_core_count != null ? p.locked_core_count : null;
   S.conjectureGray = (p.conjecture_cluster_gray != null) ? p.conjecture_cluster_gray : null;
   S.everyOnce = (p.every_surface_classified_once != null) ? p.every_surface_classified_once : null;
@@ -208,6 +221,18 @@ function _onMap(j) {
   _paintOverlay();
 }
 
+function _onBrainHealth(j) {
+  if (!j) { S.brainHealth = null; _paintOverlay(); return; }
+  S.brainHealth = j.payload || j;
+  _paintOverlay();
+}
+
+function _onBrainGaps(j) {
+  if (!j) { S.brainGaps = null; _paintOverlay(); return; }
+  S.brainGaps = j.payload || j;
+  _paintOverlay();
+}
+
 function _onOrganism(j) {
   if (!j || !_group) return;
   const p = j.payload || j;
@@ -282,10 +307,12 @@ function _clusterAxis(petal) {
 
 // place a node within a cluster's wedge: radius grows in rings, lateral fans the members out.
 function _placeNode(idKey, indexInCluster, countInCluster, ang) {
-  const perRing = 6;
+  // Adaptive packing keeps an evolving 100+ surface roster inside the camera frustum.
+  // The original fixed six-per-ring layout pushed later registry nodes far off-screen.
+  const perRing = Math.max(6, Math.min(16, Math.ceil(Math.sqrt(Math.max(1, countInCluster)) * 1.5)));
   const ring = Math.floor(indexInCluster / perRing);
   const inRing = indexInCluster % perRing;
-  const r = RING_INNER + RING_STEP * ring;
+  const r = RING_INNER + Math.min(RING_STEP, 0.78) * ring;
   // fan lateral spread within the wedge (±~26°), tightening as rings grow outward.
   const spread = (perRing > 1) ? (inRing / (perRing - 1) - 0.5) : 0;   // -0.5..0.5
   const wedge = (26 - 3 * ring) * DEG;
@@ -323,11 +350,11 @@ function _rebuildOrganism() {
 
     if (surfaces.length) {
       surfaces.forEach((s, i) => {
-        const hLabel = String(s.label || "MODELED").toUpperCase();
+        const hLabel = String(s.label || "UNSPECIFIED").toUpperCase();
         // honest label colour — the estate is NOT painted uniform.
         const nodeCol = c.gray ? C_CONJ : _labelColor(hLabel);
-        const isRoadmap = hLabel === "ROADMAP";
-        const isStruct = hLabel === "STRUCTURAL-ONLY";
+        const isRoadmap = hLabel === "ROADMAP" || hLabel === "SIMULATED";
+        const isStruct = hLabel === "STRUCTURAL-ONLY" || hLabel === "UNSPECIFIED";
         const geo = new _THREE.SphereGeometry(NODE_R, 16, 16);
         const mat = new _THREE.MeshStandardMaterial({
           color: nodeCol,
@@ -548,15 +575,17 @@ function _animate() {
 function _buildOverlay(ctx) {
   _show = createShowcase(ctx, {
     id: ID, title: TITLE, accent: "#3af4c8", badge: _badge,
-    chips: [{ label: "MODELED", name: "label" }],
+    chips: [{ label: "MODELED", name: "label" }, { label: "BRAIN: LOADING", name: "brain" }],
   });
   _overlay = document.createElement("div");
   _overlay.style.cssText = "font:12px/1.5 ui-monospace,Menlo,monospace;color:#cfe3ea;";
   _overlay.innerHTML =
-    '<div style="margin-top:2px;color:#8fb3bd;font-size:10.5px">The whole holographic estate as ONE organism — the 67 surfaces mapped by the Flower Brain\u2019s 8 real clusters. The still teal heart is the machine-proven locked-8 pistil (kernel c7c0ba17); clusters radiate out; hover a node for its honest label, click a surface to open it.</div>' +
+    '<div style="margin-top:2px;color:#8fb3bd;font-size:10.5px">The canonical holographic registry as ONE organism — measured against the same roster that builds this shell. The still teal heart is the machine-proven locked-8 pistil (kernel c7c0ba17); hover a node for its honest label, click a surface to open it.</div>' +
     _row("Total surfaces", "atlas-total") +
     _row("Clusters", "atlas-clusters") +
     _row("Coverage (all classified)", "atlas-coverage") +
+    _row("Registry source", "atlas-registry-source") +
+    _row("Registry digest", "atlas-registry-digest") +
     '<hr style="border:0;border-top:1px solid #1b3a44;margin:8px 0">' +
     '<div style="font-size:10.5px;color:#8fb3bd;margin-bottom:2px">Honest label mix (never painted uniform)</div>' +
     '<div id="atlas-labelmix" style="font-size:10.5px;color:#eaf6f9"></div>' +
@@ -567,9 +596,31 @@ function _buildOverlay(ctx) {
     '<div style="font-size:10.5px;color:#8fb3bd;margin-bottom:2px">Invariants</div>' +
     '<div id="atlas-inv" style="font-size:11px;color:#eaf6f9"></div>' +
     '<div style="margin-top:8px;display:flex;gap:10px;flex-wrap:wrap;font-size:10px;color:#9fc">' +
-      _leg(C_LOCKED, "proven / measured") + _leg(C_VERIF, "modeled") + _leg(C_GOLD, "roadmap / LF flow") +
-      _leg(C_DIM, "structural-only") + _leg(C_CONJ, "conjecture (grey)") +
+      _leg(C_LOCKED, "locked core / measured node") + _leg(C_VERIF, "modeled") + _leg(C_GOLD, "simulated / roadmap / LF flow") +
+      _leg(C_DIM, "structural / unspecified") + _leg(C_CONJ, "conjecture (grey)") +
     '</div>' +
+    '<hr style="border:0;border-top:1px solid #1b3a44;margin:9px 0">' +
+    '<div style="font-size:10.5px;color:#8fb3bd;margin-bottom:3px">Brain trust lens · live honesty signals for a query</div>' +
+    _row("Health verdict", "atlas-brain-health") +
+    _row("Signals available", "atlas-brain-components") +
+    _row("Knowledge gaps", "atlas-brain-gaps") +
+    '<div style="display:flex;gap:6px;margin-top:7px">' +
+      '<input id="atlas-brain-query" value="evidence-bound brain atlas" aria-label="Brain trust probe query" style="min-width:0;flex:1;font:10.5px ui-monospace;background:#081319;color:#dceef2;border:1px solid #1b3a44;border-radius:6px;padding:5px 7px">' +
+      '<button id="atlas-brain-run" style="font:10.5px ui-monospace;background:#0f2027;color:#9fc;border:1px solid #1b3a44;border-radius:6px;padding:4px 8px;cursor:pointer">Run probe</button>' +
+    '</div>' +
+    '<div id="atlas-brain-note" role="status" style="margin-top:5px;font-size:10px;color:#8fb3bd">A read-only query: no memory write, no model call, no action.</div>' +
+    '<details style="margin-top:9px;border-top:1px solid #1b3a44;padding-top:7px">' +
+      '<summary style="cursor:pointer;color:#9fc;font-size:10.5px">Purpose · Try · Evidence · Limits · Reproduce</summary>' +
+      '<div style="margin-top:6px;font-size:10px;color:#bcd;line-height:1.55">' +
+        '<b>Purpose.</b> Keep the estate map complete as the roster evolves, and expose whether the brain can support a query now.<br>' +
+        '<b>Try.</b> Enter a topic and run the read-only trust probe.<br>' +
+        '<b>Evidence.</b> Canonical roster digest, classified denominator, brain component availability, and structural gap verdict.<br>' +
+        '<b>Limits.</b> MODELED cartography is not truth, consciousness, or a production readiness claim. UNSPECIFIED is never promoted. Missing brain guards stay UNAVAILABLE.<br>' +
+        '<b>Reproduce.</b> <a id="atlas-open-map" href="' + EP_MAP + '" target="_blank" rel="noopener" style="color:#9fc">map JSON</a> · ' +
+        '<a id="atlas-open-health" href="' + EP_BRAIN_HEALTH + '" target="_blank" rel="noopener" style="color:#9fc">health JSON</a> · ' +
+        '<a id="atlas-open-gaps" href="' + EP_BRAIN_GAPS + '" target="_blank" rel="noopener" style="color:#9fc">gaps JSON</a>' +
+      '</div>' +
+    '</details>' +
     '<div style="margin-top:9px;display:flex;gap:8px;flex-wrap:wrap">' +
       '<button id="atlas-plain" style="font:11px ui-monospace;background:#0f2027;color:#9fc;border:1px solid #1b3a44;border-radius:6px;padding:3px 8px;cursor:pointer">Plain language</button>' +
       '<button id="atlas-info" style="font:11px ui-monospace;background:#0f2027;color:#9fc;border:1px solid #1b3a44;border-radius:6px;padding:3px 8px;cursor:pointer">What is this?</button>' +
@@ -585,6 +636,10 @@ function _buildOverlay(ctx) {
     if (box) box.style.display = box.style.display === "none" ? "block" : "none";
     if (box && box.innerHTML === "") box.innerHTML = _infoHTML();
   });
+  const rb = _overlay.querySelector("#atlas-brain-run");
+  if (rb) rb.addEventListener("click", _runBrainProbe);
+  const qi = _overlay.querySelector("#atlas-brain-query");
+  if (qi) qi.addEventListener("keydown", (e) => { if (e.key === "Enter") _runBrainProbe(); });
 }
 function _row(k, id) {
   return '<div style="display:flex;justify-content:space-between;gap:12px;margin-top:3px">' +
@@ -598,6 +653,35 @@ function _hex(n) { return "#" + (n >>> 0).toString(16).padStart(6, "0"); }
 function _esc(s) { return String(s == null ? "" : s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
 function _set(id, v) { const e = _overlay && _overlay.querySelector("#" + id); if (e) e.textContent = v; }
 
+async function _runBrainProbe() {
+  const input = _overlay && _overlay.querySelector("#atlas-brain-query");
+  const button = _overlay && _overlay.querySelector("#atlas-brain-run");
+  const note = _overlay && _overlay.querySelector("#atlas-brain-note");
+  const query = String(input && input.value || "").trim();
+  if (!query) { if (note) note.textContent = "Enter a query. Empty input is not treated as evidence."; return; }
+  const q = encodeURIComponent(query);
+  const healthUrl = "/api/a11oy/v1/brain/health?query=" + q + "&k=12";
+  const gapsUrl = "/api/a11oy/v1/brain/gaps?query=" + q + "&k=12";
+  if (button) { button.disabled = true; button.textContent = "Running…"; }
+  if (note) note.textContent = "Reading the live honesty surfaces…";
+  try {
+    const [hr, gr] = await Promise.all([fetch(healthUrl, { headers: { accept: "application/json" } }), fetch(gapsUrl, { headers: { accept: "application/json" } })]);
+    if (!hr.ok || !gr.ok) throw new Error("HTTP " + hr.status + "/" + gr.status);
+    S.brainHealth = await hr.json();
+    S.brainGaps = await gr.json();
+    S.brainProbeState = "live";
+    const oh = _overlay && _overlay.querySelector("#atlas-open-health"); if (oh) oh.href = healthUrl;
+    const og = _overlay && _overlay.querySelector("#atlas-open-gaps"); if (og) og.href = gapsUrl;
+    if (note) note.textContent = "Probe complete. Verdicts are read-only honesty signals, not a truth guarantee.";
+  } catch (e) {
+    S.brainHealth = null; S.brainGaps = null; S.brainProbeState = "error";
+    if (note) note.textContent = "NO-LIVE-DATA — the probe failed honestly (" + String(e && e.message || e).slice(0, 80) + ").";
+  } finally {
+    if (button) { button.disabled = false; button.textContent = "Run probe"; }
+    _paintOverlay();
+  }
+}
+
 function _buildTooltip(ctx) {
   _tooltip = document.createElement("div");
   _tooltip.style.cssText =
@@ -624,11 +708,17 @@ function _paintOverlay() {
   const d = deg ? "\u2014" : null;
 
   if (_show) _show.setChip("label", S.label || "MODELED");
+  if (_show) _show.setChip("brain", "BRAIN: " + (S.brainHealth && S.brainHealth.verdict ? S.brainHealth.verdict : (S.brainProbeState === "error" ? "NO-LIVE-DATA" : "LOADING")));
 
   if (missing && !S.clusters.length) {
     _set("atlas-total", nd);
     _set("atlas-clusters", "8 (Flower Brain taxonomy, offline)");
     _set("atlas-coverage", nd);
+    _set("atlas-registry-source", nd);
+    _set("atlas-registry-digest", nd);
+    _set("atlas-brain-health", S.brainHealth && S.brainHealth.verdict || nd);
+    _set("atlas-brain-components", nd);
+    _set("atlas-brain-gaps", S.brainGaps && (S.brainGaps.estate_verdict || (S.brainGaps.gaps && S.brainGaps.gaps.estate_verdict)) || nd);
     const lm = _overlay.querySelector("#atlas-labelmix"); if (lm) lm.textContent = nd + " — the map waits until the organ answers.";
     const cl = _overlay.querySelector("#atlas-clusterlist"); if (cl) cl.textContent = nd;
     const inv = _overlay.querySelector("#atlas-inv");
@@ -641,14 +731,23 @@ function _paintOverlay() {
   }
 
   const total = S.surfaceCount != null ? S.surfaceCount : null;
-  _set("atlas-total", d || (total != null ? String(total) + " (+ atlas = " + (total + 1) + ")" : "\u2014"));
+  _set("atlas-total", d || (total != null ? String(total) + " (Atlas included)" : "\u2014"));
   _set("atlas-clusters", d || (S.clustersTotal != null ? String(S.clustersTotal) + " (must be 8)" : "\u2014"));
   _set("atlas-coverage", d || (S.coverage != null ? (S.coverage * 100).toFixed(1) + "% (" + (S.totalClassified != null ? S.totalClassified : "\u2014") + "/" + (total != null ? total : "\u2014") + ")" : "\u2014"));
+  _set("atlas-registry-source", S.registry ? ((S.registry.loaded ? "CANONICAL" : "FALLBACK") + " · " + (S.registry.surface_count != null ? S.registry.surface_count : "—")) : "\u2014");
+  _set("atlas-registry-digest", S.registry && S.registry.sha256 ? S.registry.sha256.slice(0, 16) + "…" : "\u2014");
+
+  const health = S.brainHealth || null;
+  const healthSummary = health && health.summary || {};
+  const gaps = S.brainGaps || null;
+  _set("atlas-brain-health", health && health.verdict ? String(health.verdict) : (S.brainProbeState === "error" ? "NO-LIVE-DATA" : "LOADING"));
+  _set("atlas-brain-components", health ? String(healthSummary.components_available != null ? healthSummary.components_available : "—") + "/" + String(healthSummary.components_total != null ? healthSummary.components_total : "—") : "\u2014");
+  _set("atlas-brain-gaps", gaps ? String(gaps.estate_verdict || (gaps.gaps && gaps.gaps.estate_verdict) || "UNSPECIFIED") : "\u2014");
 
   // honest label mix — rendered by real label, coloured by label type (NOT uniform).
   const lm = _overlay.querySelector("#atlas-labelmix");
   if (lm) {
-    const order = ["MODELED", "STRUCTURAL-ONLY", "ROADMAP", "MEASURED"];
+    const order = ["MODELED", "MEASURED", "STRUCTURAL-ONLY", "SIMULATED", "ROADMAP", "UNSPECIFIED"];
     const keys = order.filter((k) => S.labelMix[k] != null).concat(Object.keys(S.labelMix).filter((k) => order.indexOf(k) < 0));
     if (!keys.length) { lm.textContent = deg ? "\u2014" : "\u2014"; }
     else {
@@ -686,6 +785,8 @@ function _paintOverlay() {
       _check("clusters == 8", clustersOk) +
       _check("locked-core == 8", lockedOk) +
       _check("coverage 1.0", covOk) +
+      _check("canonical registry loaded", S.registry ? S.registry.loaded === true : null) +
+      _check("registry duplicate ids == 0", S.registry && Array.isArray(S.registry.duplicate_ids) ? S.registry.duplicate_ids.length === 0 : null) +
       _check("conjecture grey (never green)", grayOk);
   }
 
@@ -702,15 +803,20 @@ function _applyPlain() {
   if (!box) return;
   box.style.display = _plain ? "block" : "none";
   if (_plain) {
+    const total = S.surfaceCount != null ? S.surfaceCount : "the current";
+    const c6 = S.clusters.find((c) => c.key === "surfaces");
+    const c7 = S.clusters.find((c) => c.key === "memory");
+    const n6 = c6 && c6.surface_count != null ? c6.surface_count : "many";
+    const n7 = c7 && c7.surface_count != null ? c7.surface_count : "the brain and memory";
     box.innerHTML =
-      "This is our <b>entire holographic estate drawn as one organism</b>. We have 67 surfaces (tabs); " +
+      "This is our <b>entire holographic estate drawn as one organism</b>. The canonical shell currently declares <b>" + total + " surfaces</b>, Atlas included; " +
       "on their own they look like a flat wall. The Atlas gives them a spine by <b>mapping every surface " +
       "into the Flower Brain\u2019s 8 real clusters</b> \u2014 the ecosystem\u2019s own taxonomy \u2014 without removing a " +
       "single surface. The solid teal ball in the middle is the <b>pistil: the 8 things we have actually " +
       "machine-proven</b> (locked-8, kernel c7c0ba17). It never grows. Around it, eight regions fan out; most " +
-      "of the surfaces live in the big <b>SURFACES</b> region (58), a smaller set in <b>MEMORY &amp; PROVENANCE</b> " +
-      "(9), and the rest of the clusters carry the flower\u2019s kernel objects. <b>Hover any node</b> to see its " +
-      "surface name and its honest label (MODELED, STRUCTURAL-ONLY, ROADMAP, or MEASURED \u2014 we do not paint " +
+      "of the surfaces live in the big <b>SURFACES</b> region (" + n6 + "), with <b>MEMORY &amp; PROVENANCE</b> " +
+      "carrying " + n7 + ". The rest of the clusters carry the flower\u2019s kernel objects. <b>Hover any node</b> to see its " +
+      "surface name and its honest label (including UNSPECIFIED when the registry makes no maturity claim \u2014 we do not paint " +
       "them all the same); <b>click a surface</b> to jump straight to it. The gold arcs are <b>Loop Forge\u2019s " +
       "living process</b> (propose \u2192 kernel gate \u2192 archive). The grey region is our <b>conjectures we have NOT " +
       "proven</b>; it stays grey and never turns green. Label is <b>" + (S.label || "MODELED") + "</b>: a faithful " +
@@ -720,16 +826,19 @@ function _applyPlain() {
 }
 
 function _infoHTML() {
+  const total = S.surfaceCount != null ? S.surfaceCount : "the canonical roster";
+  const digest = S.registry && S.registry.sha256 ? S.registry.sha256.slice(0, 16) + "…" : "pending";
   return "<b>This is the estate as one organism, mapped by the Flower Brain\u2019s 8 clusters.</b> " +
-    "Unification by cartography: the flat 67-tab wall is given a spine by classifying every surface into " +
+    "Unification by cartography: the shell roster is given a spine by classifying every surface into " +
     "the 8 real clusters of the <b>Flower Brain</b> (the taxonomy source) \u2014 additively, with no surface removed. " +
     "The still center is the machine-proven <b>locked-8 pistil</b> {F1,F4,F7,F11,F12,F18,F19,F22}, carried from " +
     "the lutar-lean kernel <b>c7c0ba17</b> (cited; re-verified in CI/dev, not in-Space). " +
     "<br><br><b>What is MODELED vs real.</b> The classification is REAL \u2014 each surface maps to its cluster by its " +
-    "actual nature/owner/domain, served by the backend organ szl_kc_atlas and proven complete (coverage 1.0, zero " +
-    "orphans, all 67 mapped once; the Atlas itself is the 68th). The LAYOUT is a <b>MODELED</b> deterministic drawing " +
+    "actual declared category/domain, served by the backend organ szl_kc_atlas and checked complete against " + total +
+    " canonical entries (coverage 1.0, zero orphans, Atlas included; roster digest <code>" + digest + "</code>). The LAYOUT is a <b>MODELED</b> deterministic drawing " +
     "read verbatim from <code>/api/a11oy/v1/atlas/{map,organism}</code> \u2014 not a computation, not \u201Calive.\u201D The honest " +
-    "label mix (58 MODELED / 7 STRUCTURAL-ONLY / 1 ROADMAP / 1 MEASURED) is rendered per surface, never uniform. " +
+    "label mix is returned by the endpoint and rendered per surface, never hard-coded or uniform. A new surface " +
+    "without an explicit maturity claim is UNSPECIFIED, never silently promoted. " +
     "\u039B stays <b>Conjecture 1</b>, the conjecture cluster is <b>grey, never green</b>. " +
     "<br><br><b>Sources (we cite the taxonomy; we do not claim it as computation).</b><br>" +
     "&bull; Taxonomy source \u2014 the Flower Brain: <code>github.com/szl-holdings/killinchu szl_kc_flower.py</code><br>" +
@@ -774,7 +883,8 @@ function unmount() {
   S.clusters = []; S.petals = []; S.petalByCluster = {}; S.crossLinks = []; S.lfFlow = null;
   S.clustersTotal = S.surfaceCount = S.totalClassified = S.coverage = null;
   S.lockedCoreCount = S.conjectureGray = S.everyOnce = null;
+  S.registry = null; S.brainHealth = null; S.brainGaps = null; S.brainProbeState = "init";
   S.labelMix = {}; S.built = false;
 }
 
-export default { id: ID, title: TITLE, endpoints: [EP_MAP, EP_ORGANISM], mount, unmount };
+export default { id: ID, title: TITLE, endpoints: [EP_MAP, EP_ORGANISM, EP_BRAIN_HEALTH, EP_BRAIN_GAPS], mount, unmount };

szl3d_holographic.py

@@ -150,7 +150,7 @@ SURFACES: List[Dict[str, str]] = [
     {"id": "brainexplain", "cat": "brain", "title": "Brain Explain · transparent explanation of WHY the brain retrieved what it did · MODELED descriptive trace over the REAL retrieval subgraph (which query terms matched which seed nodes, per-node ppr-vs-salience rationale, communities traversed, each node's OWN label VERBATIM) → EXPLAINABLE/PARTIALLY-EXPLAINABLE/OPAQUE (never invents a rationale; honest OPAQUE beats a fake one), unsigned SHA-256 receipt-on-write", "owner": "WaveT-Dev1"},
     {"id": "braingaps", "cat": "brain", "title": "Brain Gaps · an honest map of what the brain does NOT know · MEASURED thin (sparse) communities + weakly-connected island nodes (degree≤1) + weak-label share over the live graph, and per-query COVERED/THIN/GAP grounding → estate verdict WELL-COVERED/PATCHY/SPARSE (a GAP is never fabricated into coverage), unsigned SHA-256 receipt-on-write (MODELED)", "owner": "WaveT-Dev1"},
     {"id": "brainconstitution", "cat": "brain", "title": "Brain Constitution · the honest, machine-checkable ruleset the brain is graded against per query · an explicit ordered set of ARTICLES (grounding sufficiency, calibrated confidence, honest corroboration, contradictions surfaced, traceable to source, freshness honesty, coverage gaps admitted, doctrine invariants) each graded COMPLIANT/VIOLATED/UNAVAILABLE against whatever sibling brain-honesty surfaces are importable (an absent surface is UNAVAILABLE, never a fabricated pass) → CONSTITUTIONAL/IN-VIOLATION/INSUFFICIENT-SIGNAL, never CONSTITUTIONAL while any evaluable Article is VIOLATED, unsigned SHA-256 receipt-on-write (MODELED)", "owner": "WaveT-Dev1"},
-    {"id": "markets", "cat": "finance", "flag": True, "title": "Markets & Finance · live Polymarket prediction book (top markets by 24h volume, pillar height = 24h vol, bead = YES probability) + crypto majors orbiting by market cap · 100% MEASURED same-origin deva finance feeds, no mocked spend/keys, log-scaling is display-only", "owner": "Forge"},
+    {"id": "markets", "module": "finance", "cat": "finance", "flag": True, "title": "Markets & Finance · live Polymarket prediction book (top markets by 24h volume, pillar height = 24h vol, bead = YES probability) + crypto majors orbiting by market cap · 100% MEASURED same-origin deva finance feeds, no mocked spend/keys, log-scaling is display-only", "owner": "Forge"},
     {"id": "leaders", "cat": "more", "flag": True, "title": "Frontier Models · Live AI Leaders · MEASURED live OpenRouter model catalog — one pillar per lab (height = max context window, bead = open/free share); widest-context models orbit as satellites (teal = free, amber = paid); log-scaling is display-only, no invented benchmark or ranking", "owner": "Forge"},
    {"id": "research", "cat": "more", "flag": True, "title": "Frontier Research · Live arXiv AI · MEASURED live arXiv submission stream (cs.AI/LG/CL/CV/NE) — one pillar per research category (height = fresh-paper count, bead = share of the window); most-recent papers orbit as satellites sized by author count; log-scaling is display-only, no citation count, score, or ranking", "owner": "Forge"},
     {"id": "open", "cat": "more", "flag": True, "title": "Open Frontier · Live Hugging Face · MEASURED live Hugging Face Hub trending stream — one pillar per org/author (height = summed likes, bead = download reach); most-liked open models orbit as satellites coloured by task; log-scaling is display-only, no invented benchmark, score, or ranking beyond the Hub’s own", "owner": "Forge"},
@@ -329,7 +329,9 @@ def _selftest() -> None:
         assert (base / f).is_file(), f"missing toolkit asset: {f}"
     # 2. all surface modules exist (frontier tier + the 9 estate surfaces)
     for s in SURFACES:
-        assert (base / "surfaces" / f"{s['id']}.js").is_file(), f"missing surface: {s['id']}"
+        module_id = s.get("module", s["id"])
+        assert (base / "surfaces" / f"{module_id}.js").is_file(), \
+            f"missing surface module: {s['id']} -> {module_id}.js"
     # 3. path traversal is rejected
     assert _safe_resolve(base, "../serve.py") is None
     assert _safe_resolve(base, "../../etc/passwd") is None

szl_kc_atlas.py

@@ -3,13 +3,13 @@
 # Doctrine v11 LOCKED: locked-proven=8 · Λ=Conjecture 1 · SLSA L1 honest / L2 attested / L3 roadmap
 # Co-Authored-By: Perplexity Computer Agent
 """
-szl_kc_atlas.py — THE ATLAS (68th surface) — the unifying front door that maps the
-whole 67-surface holographic estate into ONE organism using the Flower Brain's 8 real
+szl_kc_atlas.py — THE ATLAS — the unifying front door that maps the
+canonical holographic registry into ONE organism using the Flower Brain's 8 real
 clusters as the taxonomy. Backs a11oy static/3d/surfaces/atlas.js.
 
-The estate serves 67 surfaces as a flat wall of monospace tabs — no hierarchy, no story.
+The estate serves an evolving surface roster as a flat wall of monospace tabs — no hierarchy, no story.
 The answer is already in the ecosystem: the Flower Brain (surface 65) defines 8 real
-clusters. The Atlas classifies EVERY one of the 67 surfaces into exactly one of those 8
+clusters. The Atlas classifies EVERY surface in the canonical registry into exactly one of those 8
 clusters (zero orphans, coverage 1.0), carries the flower's KERNEL objects (locked-8,
 theorems, codexes, Λ conjecture) as the still center, and shows the estate as one
 organism: a locked-8 pistil, 8 petals with their member surfaces, cross-links (which
@@ -22,35 +22,36 @@ github.com/szl-holdings/killinchu szl_kc_flower.py):
   3 EXPERIMENTAL       — CI-green experimental / agentic theorems.
   4 UNIFIED FORMULAS   — cited borrowed structure (DOIs), never claimed as SZL's own.
   5 OUROBOROS CODEXES  — the bounded-recursion self-referential codex layer.
-  6 SURFACES           — the live 3D surface organs (most of the 67 map here, sub-tagged).
+  6 SURFACES           — the live 3D surface organs (most of the roster maps here, sub-tagged).
   7 MEMORY & PROVENANCE— HEART/BLOOD + A-MEM spine; episodic/graph/agent memory + anatomy.
   8 CONJECTURES        — Λ Conjecture 1, Khipu, self-repair (GRAY, never green).
 
 Routes (NEW; never collide):
   GET /api/{ns}/v1/atlas/manifest  — organ manifest + honesty_invariants
-  GET /api/{ns}/v1/atlas/map       — the REAL per-surface classification of all 67 + coverage proof
+  GET /api/{ns}/v1/atlas/map       — the REAL per-surface classification + denominator + coverage proof
   GET /api/{ns}/v1/atlas/organism  — estate-as-organism view: pistil, 8 petals, cross-links, LF flow
 
 HONESTY SPINE (Doctrine v11 — NON-NEGOTIABLE):
   * label "MODELED" returned verbatim on every endpoint; never upgraded.
   * clusters == 8, locked_core == 8 (immutable pistil {F1,F4,F7,F11,F12,F18,F19,F22}).
   * conjecture cluster (8) renders GRAY, never green — assert conjecture_rendered_green == 0.
-  * coverage == 1.0: EVERY one of the 67 surfaces is classified into exactly one cluster —
-    zero orphans, zero double-counts. The Atlas itself is the 68th surface (its own home is
-    cluster 6). __main__ verifies this against the embedded 67.
+  * coverage == 1.0: EVERY canonical registry surface, including Atlas, is classified into
+    exactly one cluster — zero orphans, zero double-counts. __main__ verifies this against
+    szl3d_holographic.SURFACES and publishes the denominator + registry digest.
   * classification basis is REAL and cited per-cluster (derived from each surface's actual
     nature/owner/domain), NEVER arbitrary. The taxonomy source is the Flower Brain
     (szl_kc_flower.py). Bridges (loopforge -> OUROBOROS+CONJECTURE, flower -> all) are cited.
   * no consciousness/sentience/alive claim.
   * banned marketing tokens rejected (reversed-fragment guard); every Λ/theorem line keeps its qualifier inline (Λ = Conjecture 1, never a theorem) so the honesty gate never trips.
   * Pure stdlib (seeded LCG, no numpy, no stdlib random). Deterministic: same seed =>
-    identical snapshot. The 67 surfaces are EMBEDDED as a Python literal (a snapshot of
-    /api/a11oy/v1/frontier/surfaces) so the organ is self-contained — never fetched at runtime.
+    identical snapshot. The embedded Wave-27 surface list is retained only as a vetted label
+    source/fallback; the canonical local shell registry defines current coverage.
 
 Pure stdlib. Defensive: a compute failure NEVER raises out of a handler.
 """
 from __future__ import annotations
 
+import hashlib as _hashlib
 import json as _json
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -262,10 +263,10 @@ LIVE_SURFACES: List[Dict[str, str]] = [
     {"id": "loopforge",      "title": "Loop Forge",                                        "label": "MODELED"},
 ]
 _SURFACE_IDS = tuple(s["id"] for s in LIVE_SURFACES)
-SURFACE_COUNT = len(LIVE_SURFACES)  # 67
+SURFACE_COUNT = len(LIVE_SURFACES)  # reconciled below against the canonical shell registry
 
 # =====================================================================================
-# THE CLASSIFICATION — each of the 67 surfaces -> exactly ONE cluster, by its REAL nature.
+# THE CLASSIFICATION — each canonical surface -> exactly ONE cluster, by its declared nature.
 # Basis is DEFENSIBLE and cited per-cluster (see _CLASSIFICATION_BASIS). Not arbitrary:
 #   * MEMORY & PROVENANCE (7): surfaces whose PRIMARY organ is memory storage/retrieval,
 #     provenance/receipts, or the estate's anatomy/self-map (episodic, titans, graphmem,
@@ -358,6 +359,107 @@ _SURFACE_CLUSTER: Dict[str, Tuple[int, str]] = {
     "loopforge":    (6, "Loop Forge surface — the living process (bridges to OUROBOROS+CONJECTURE)"),
 }
 
+# =====================================================================================
+# CANONICAL ROSTER ALIGNMENT — the holographic shell is the source of truth.
+#
+# The original Atlas embedded a 67-surface snapshot. The shell continued to evolve, which
+# allowed the Atlas to keep reporting coverage=1.0 over a stale denominator while dozens of
+# newer surfaces were absent. We now reconcile the embedded label snapshot against
+# szl3d_holographic.SURFACES at import time. The import is local, deterministic and
+# fail-closed: if the canonical module is unavailable we expose the embedded snapshot and
+# mark registry_loaded=False instead of pretending it is current.
+#
+# New registry entries inherit their declared shell category for classification:
+# brain/anatomy -> MEMORY & PROVENANCE; everything else -> SURFACES. Their maturity label
+# is NEVER guessed. A label is reused only when present in the vetted embedded snapshot or
+# written explicitly in the canonical title; otherwise it is UNSPECIFIED.
+# =====================================================================================
+_EMBEDDED_SURFACES = tuple(dict(s) for s in LIVE_SURFACES)
+_EMBEDDED_LABELS = {s["id"]: s["label"] for s in _EMBEDDED_SURFACES}
+_EXPLICIT_LABELS = ("STRUCTURAL-ONLY", "MEASURED", "SIMULATED", "ROADMAP", "MODELED")
+
+
+def _declared_label(surface_id: str, title: str) -> Tuple[str, str]:
+    if surface_id == "atlas":
+        return MODELED_LABEL, "atlas-contract"
+    if surface_id in _EMBEDDED_LABELS:
+        return _EMBEDDED_LABELS[surface_id], "embedded-vetted-snapshot"
+    upper = str(title or "").upper()
+    for label in _EXPLICIT_LABELS:
+        if label in upper:
+            return label, "canonical-title-explicit"
+    return "UNSPECIFIED", "canonical-registry-no-maturity-claim"
+
+
+def _canonical_roster() -> Tuple[List[Dict[str, str]], Dict[str, Any]]:
+    source = "embedded-snapshot"
+    loaded = False
+    error: Optional[str] = None
+    try:
+        from szl3d_holographic import SURFACES as shell_surfaces
+
+        raw = list(shell_surfaces)
+        source = "szl3d_holographic.SURFACES"
+        loaded = True
+    except Exception as exc:  # pragma: no cover - deployment fallback is reported in payload
+        raw = [
+            {"id": "atlas", "cat": "map", "title": "Atlas", "owner": "atlas-contract"},
+            *_EMBEDDED_SURFACES,
+        ]
+        error = "%s: %s" % (type(exc).__name__, str(exc)[:160])
+
+    rows: List[Dict[str, str]] = []
+    seen = set()
+    duplicate_ids: List[str] = []
+    for item in raw:
+        sid = str(item.get("id") or "").strip()
+        if not sid:
+            continue
+        if sid in seen:
+            duplicate_ids.append(sid)
+            continue
+        seen.add(sid)
+        title = str(item.get("title") or sid)
+        label, label_source = _declared_label(sid, title)
+        rows.append({
+            "id": sid,
+            "title": title,
+            "label": label,
+            "label_source": label_source,
+            "cat": str(item.get("cat") or "more"),
+            "owner": str(item.get("owner") or "UNSPECIFIED"),
+            "module": str(item.get("module") or sid),
+        })
+
+    canonical = [{k: r[k] for k in ("id", "title", "cat", "owner", "module")} for r in rows]
+    digest = _hashlib.sha256(
+        _json.dumps(canonical, sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+    ).hexdigest()
+    return rows, {
+        "source": source,
+        "loaded": loaded,
+        "error": error,
+        "sha256": digest,
+        "surface_count": len(rows),
+        "duplicate_ids": sorted(set(duplicate_ids)),
+    }
+
+
+LIVE_SURFACES, _REGISTRY_META = _canonical_roster()
+_SURFACE_IDS = tuple(s["id"] for s in LIVE_SURFACES)
+SURFACE_COUNT = len(LIVE_SURFACES)
+
+# Reconcile classification against the canonical registry. Existing authored mappings retain
+# their specific sub-tags; new entries receive a deterministic tag derived from the shell's
+# own declared category. This makes orphans visible and prevents stale-denominator success.
+for _surface in LIVE_SURFACES:
+    _sid = _surface["id"]
+    if _sid in _SURFACE_CLUSTER:
+        continue
+    _cat = str(_surface.get("cat") or "more").lower()
+    _cluster = 7 if _cat in ("brain", "anatomy") else 6
+    _SURFACE_CLUSTER[_sid] = (_cluster, "%s registry surface (canonical shell category)" % _cat)
+
 # Per-cluster classification BASIS (cited to the Flower Brain taxonomy source). Every
 # cluster + bridge cites a real basis — this is the honest, non-arbitrary rationale.
 _CLASSIFICATION_BASIS: Dict[int, str] = {
@@ -430,12 +532,13 @@ _BRIDGES: List[Tuple[str, int, str, str]] = [
 ]
 
 _HONEST_NOTE = (
-    "MODELED: The Atlas is a MODELED cartography that unifies the live 67-surface estate into "
+    "MODELED: The Atlas is a MODELED cartography that unifies the canonical holographic estate into "
     "ONE organism using the Flower Brain's 8 real clusters as the taxonomy (source: "
     "github.com/szl-holdings/killinchu szl_kc_flower.py). The classification is REAL and cited "
     "per-cluster (derived from each surface's actual nature/owner/domain), NEVER arbitrary. EVERY "
-    "one of the 67 surfaces is classified into exactly ONE cluster — zero orphans, zero double-"
-    "counts, coverage 1.0 — and the Atlas itself is the 68th surface (its home is cluster 6). The "
+    "surface in szl3d_holographic.SURFACES, including the Atlas, is classified into exactly ONE "
+    "cluster — zero orphans, zero double-counts. The denominator, source and SHA-256 registry digest "
+    "are returned on every endpoint, so stale-roster coverage cannot masquerade as completeness. The "
     "kernel clusters (PROVEN CORE, VERIFIED, EXPERIMENTAL, UNIFIED, OUROBOROS, CONJECTURE) carry "
     "the flower's KERNEL objects (locked-8, theorems, cited formulas, codexes, the Λ conjecture); "
     "surfaces BRIDGE to them (loopforge -> ouroboros+conjecture, flower -> all clusters) — every "
@@ -443,9 +546,10 @@ _HONEST_NOTE = (
     "and is the immutable pistil that NEVER grows. The conjecture cluster (Λ Conjecture 1, machine-"
     "checked FALSE; Khipu BFT; self-repair) renders GRAY, never green. The Loop-Forge flow overlay "
     "(proposer -> kernel gate -> archive) is a MODELED process view, NOT a claim that anything is "
-    "trained, alive, or conscious. The 67 surfaces are an EMBEDDED verbatim snapshot of "
-    "/api/a11oy/v1/frontier/surfaces (labels read verbatim, never upgraded); the organ is self-"
-    "contained and never fetches at runtime. Deterministic: same seed => identical snapshot. Pure "
+    "trained, alive, or conscious. Maturity labels are reused only from the vetted embedded snapshot "
+    "or an explicit canonical title; otherwise the label is UNSPECIFIED, never guessed. The organ "
+    "imports its local canonical registry and never fetches a network dependency at runtime. "
+    "Deterministic: same registry + seed => identical snapshot. Pure "
     "stdlib, no numpy, no stdlib random."
 )
 
@@ -457,7 +561,7 @@ CITATIONS: Dict[str, str] = {
     "locked_count_eight (no-axiom theorem)": _LL + "Lutar/Wave11/AxiomDisclosure.lean",
     "szl_heart_blood (HEART sigma-bus + BLOOD DSSE hash-chain memory spine)": _A11OY + "szl_heart_blood.py",
     "A-MEM agentic memory (Xu et al., NeurIPS 2025)": "https://arxiv.org/abs/2502.12110",
-    "live surface list (embedded snapshot source)": "https://a-11-oy.com/api/a11oy/v1/frontier/surfaces",
+    "live surface list (public registry view)": "https://a-11-oy.com/api/a11oy/v1/holographic/info",
     "a11oy holographic.html SURFACES (surface registry)": _A11OY + "static/3d/holographic.html",
 }
 
@@ -468,7 +572,7 @@ CITATIONS: Dict[str, str] = {
 # =====================================================================================
 def _classify() -> Dict[str, Any]:
     """Return {cluster_n -> {surfaces:[...], kernel_objects:[...]}} + coverage bookkeeping.
-    Asserts EVERY one of the 67 surfaces is assigned to exactly one cluster."""
+    Asserts EVERY canonical registry surface is assigned to exactly one cluster."""
     # every surface must be in _SURFACE_CLUSTER exactly once
     assigned_ids = list(_SURFACE_CLUSTER.keys())
     # detect orphans (a live surface with no assignment) and unknowns (assignment w/o a surface)
@@ -486,7 +590,7 @@ def _classify() -> Dict[str, Any]:
     for c in CLUSTERS:
         per_cluster[c["n"]] = {"surfaces": [], "kernel_objects": []}
 
-    for sid in _SURFACE_IDS:  # iterate in the canonical embedded order (deterministic)
+    for sid in _SURFACE_IDS:  # iterate in canonical registry order (deterministic)
         cn, sub = _SURFACE_CLUSTER[sid]
         per_cluster[cn]["surfaces"].append({
             "id": sid, "title": title_of[sid], "label": label_of[sid], "sub_tag": sub,
@@ -502,7 +606,7 @@ def _classify() -> Dict[str, Any]:
         "orphans": orphans,
         "unknown_assignments": unknown,
         "double_counts": sorted(set(double_counts)),
-        "total_classified": total_classified,     # MUST equal SURFACE_COUNT (67)
+        "total_classified": total_classified,     # MUST equal canonical SURFACE_COUNT
         "title_of": title_of,
         "label_of": label_of,
     }
@@ -534,7 +638,7 @@ def _valid_bridges() -> List[Dict[str, Any]]:
 
 
 # =====================================================================================
-# /map — the REAL classification: all 67 surfaces mapped to the 8 clusters + coverage proof.
+# /map — the REAL classification: canonical surfaces mapped to 8 clusters + coverage proof.
 # =====================================================================================
 def atlas_map(seed: int = 42) -> Dict[str, Any]:
     cl = _classify()
@@ -562,7 +666,7 @@ def atlas_map(seed: int = 42) -> Dict[str, Any]:
         })
 
     bridges = _valid_bridges()
-    # coverage proof: every one of the 67 appears exactly once across all clusters
+    # coverage proof: every canonical registry surface appears exactly once across all clusters
     seen: Dict[str, int] = {}
     for c in clusters_out:
         for s in c["surfaces"]:
@@ -577,17 +681,21 @@ def atlas_map(seed: int = 42) -> Dict[str, Any]:
         "kernel": KERNEL_ID,
         "seed": int(seed),
         "taxonomy_source": _FLOWER_SRC,
+        "registry": dict(_REGISTRY_META),
         "clusters_total": len(CLUSTERS),                # 8
         "clusters": clusters_out,
-        "surface_count": SURFACE_COUNT,                 # 67
-        "total_classified": cl["total_classified"],     # MUST == 67
+        "surface_count": SURFACE_COUNT,
+        "coverage_denominator": "szl3d_holographic.SURFACES",
+        "total_classified": cl["total_classified"],
         "coverage": coverage,                            # MUST == 1.0
         "orphans": cl["orphans"],                        # MUST be []
         "unknown_assignments": cl["unknown_assignments"],  # MUST be []
         "double_counts": cl["double_counts"],            # MUST be []
         "every_surface_classified_once": bool(each_once),  # MUST be True
-        "atlas_is_68th": {"id": "atlas", "home_cluster": 6,
-                          "note": "the Atlas surface itself is the 68th; its home is cluster 6 SURFACES"},
+        "atlas_membership": {"id": "atlas", "home_cluster": 6, "included_in_surface_count": True},
+        "atlas_is_68th": {"id": "atlas", "home_cluster": 6, "legacy_field": True,
+                          "current": False, "included_in_surface_count": True,
+                          "note": "legacy compatibility field; Atlas is now included in the canonical registry denominator"},
         "bridges": bridges,
         "cross_cluster_bridges": sum(1 for b in bridges if b["cross_cluster"]),
         "locked_core": list(LOCKED8_IDS),
@@ -675,13 +783,15 @@ def atlas_organism(seed: int = 42) -> Dict[str, Any]:
         "kernel": KERNEL_ID,
         "seed": int(seed),
         "taxonomy_source": _FLOWER_SRC,
+        "registry": dict(_REGISTRY_META),
         "center": center,                          # the immutable locked-8 pistil
         "petals": petals,                          # 8 petals w/ member surfaces + kernel objects
         "petals_total": len(petals),               # 8
         "cross_links": cross_links,                # which surfaces bridge clusters
         "cross_links_total": len(cross_links),
         "loop_forge_flow": lf_flow,                # proposer -> kernel -> archive overlay
-        "surface_count": SURFACE_COUNT,            # 67
+        "surface_count": SURFACE_COUNT,
+        "coverage_denominator": "szl3d_holographic.SURFACES",
         "coverage": m["coverage"],                 # 1.0
         "locked_core": list(LOCKED8_IDS),
         "locked_core_count": len(LOCKED8_IDS),     # 8
@@ -725,16 +835,17 @@ def atlas_manifest(seed: int = 42) -> Dict[str, Any]:
     return {
         "service": "atlas",
         "surface": "atlas",
-        "surface_index": 68,
+        "surface_index": _SURFACE_IDS.index("atlas") + 1 if "atlas" in _SURFACE_IDS else None,
         "label": MODELED_LABEL,
         "doctrine": DOCTRINE_VERSION,
         "kernel": KERNEL_ID,
         "seed": int(seed),
-        "summary": ("The Atlas unifies the live 67-surface holographic estate into ONE organism "
+        "summary": ("The Atlas unifies the canonical holographic registry into ONE organism "
                     "using the Flower Brain's 8 real clusters as the taxonomy. Every surface is "
                     "classified into exactly one cluster (coverage 1.0); the locked-8 pistil is the "
                     "immutable center; conjectures stay GRAY. Cartography, not a new surface layer."),
         "taxonomy_source": _FLOWER_SRC,
+        "registry": dict(_REGISTRY_META),
         "endpoints": [
             "/api/<ns>/v1/atlas/manifest",
             "/api/<ns>/v1/atlas/map",
@@ -749,18 +860,20 @@ def atlas_manifest(seed: int = 42) -> Dict[str, Any]:
             "kernel_object_count": len(c["kernel_object_ids"]),
             "label_mix": c["label_mix"],
         } for c in m["clusters"]],
-        "surface_count": SURFACE_COUNT,                  # 67
-        "total_classified": m["total_classified"],        # 67
+        "surface_count": SURFACE_COUNT,
+        "coverage_denominator": "szl3d_holographic.SURFACES",
+        "total_classified": m["total_classified"],
         "coverage": m["coverage"],                        # 1.0
         "orphans": m["orphans"],                          # []
         "double_counts": m["double_counts"],              # []
-        "overall_label_mix": overall_mix,                 # honest label mix over all 67
+        "overall_label_mix": overall_mix,                 # honest label mix over canonical roster
         "locked_core": list(LOCKED8_IDS),
         "locked_core_count": m["locked_core_count"],      # 8
         "conjecture_cluster_gray": m["conjecture_cluster_gray"],  # True
         "conjecture_rendered_green": conjecture_rendered_green,   # 0
         "bridges_total": len(m["bridges"]),
         "cross_cluster_bridges": m["cross_cluster_bridges"],
+        "atlas_membership": m["atlas_membership"],
         "atlas_is_68th": m["atlas_is_68th"],
         "honesty_invariants": honesty_invariants,
         "citations": CITATIONS,
@@ -872,9 +985,9 @@ if __name__ == "__main__":
     assert org["center"]["is_pistil"] is True and org["center"]["immutable"] is True
     assert [o["id"] for o in org["center"]["locked8"]] == list(LOCKED8_IDS)
 
-    # coverage 1.0: EVERY one of the 67 surfaces classified exactly once, zero orphans
-    assert m["surface_count"] == 67, "estate must be 67 surfaces"
-    assert m["total_classified"] == 67, "all 67 must be classified"
+    # coverage 1.0: EVERY canonical surface classified exactly once, zero orphans
+    assert m["surface_count"] == len(_SURFACE_IDS) == SURFACE_COUNT
+    assert m["total_classified"] == SURFACE_COUNT, "all canonical surfaces must be classified"
     assert m["coverage"] == 1.0, "coverage must be 1.0"
     assert m["orphans"] == [], "zero orphans"
     assert m["unknown_assignments"] == [], "zero unknown assignments"
@@ -885,12 +998,14 @@ if __name__ == "__main__":
     for c in m["clusters"]:
         for s in c["surfaces"]:
             seen[s["id"]] = seen.get(s["id"], 0) + 1
-    assert set(seen.keys()) == set(_SURFACE_IDS), "cluster members must be exactly the 67"
+    assert set(seen.keys()) == set(_SURFACE_IDS), "cluster members must equal canonical registry"
     assert all(v == 1 for v in seen.values()), "no surface may appear twice"
-    assert sum(seen.values()) == 67
+    assert sum(seen.values()) == SURFACE_COUNT
 
-    # atlas itself is the 68th surface (home cluster 6)
-    assert m["atlas_is_68th"]["home_cluster"] == 6 and mf["surface_index"] == 68
+    # Atlas is part of the denominator and lives in cluster 6.
+    assert m["atlas_membership"]["home_cluster"] == 6
+    assert m["atlas_membership"]["included_in_surface_count"] is True
+    assert "atlas" in _SURFACE_IDS and mf["surface_index"] == _SURFACE_IDS.index("atlas") + 1
 
     # each cluster populated (surfaces OR kernel objects) + basis cited to the flower
     for c in m["clusters"]:
@@ -994,7 +1109,7 @@ if __name__ == "__main__":
     ], paths
 
     print("register paths:", paths)
-    print("szl_kc_atlas: ALL OK — 67 surfaces unified into 8 flower clusters, coverage 1.0, "
+    print("szl_kc_atlas: ALL OK — canonical surfaces unified into 8 flower clusters, coverage 1.0, "
           "locked-8 immutable pistil, conjectures gray, cited basis per cluster, deterministic.",
           file=sys.stderr)
     print("ALL OK")

test/test_atlas_registry_alignment.py

@@ -0,0 +1,69 @@
+"""Regression tests for the canonical Atlas roster and brain-trust lens."""
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+
+import szl3d_holographic
+import szl_kc_atlas
+
+
+class AtlasRegistryAlignmentTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.map = szl_kc_atlas.atlas_map(seed=42)
+
+    def test_denominator_is_the_canonical_shell_registry(self) -> None:
+        shell_ids = [row["id"] for row in szl3d_holographic.SURFACES]
+        atlas_ids = [
+            row["id"]
+            for cluster in self.map["clusters"]
+            for row in cluster["surfaces"]
+        ]
+        self.assertEqual(self.map["registry"]["source"], "szl3d_holographic.SURFACES")
+        self.assertTrue(self.map["registry"]["loaded"])
+        self.assertEqual(self.map["surface_count"], len(shell_ids))
+        self.assertCountEqual(atlas_ids, shell_ids)
+        self.assertEqual(len(atlas_ids), len(set(atlas_ids)))
+
+    def test_coverage_cannot_hide_roster_drift(self) -> None:
+        self.assertEqual(self.map["coverage_denominator"], "szl3d_holographic.SURFACES")
+        self.assertEqual(self.map["total_classified"], self.map["surface_count"])
+        self.assertEqual(self.map["coverage"], 1.0)
+        self.assertEqual(self.map["orphans"], [])
+        self.assertEqual(self.map["unknown_assignments"], [])
+        self.assertEqual(self.map["double_counts"], [])
+        self.assertRegex(self.map["registry"]["sha256"], r"^[0-9a-f]{64}$")
+
+    def test_atlas_is_included_and_unclaimed_labels_stay_unspecified(self) -> None:
+        by_id = {
+            row["id"]: row
+            for cluster in self.map["clusters"]
+            for row in cluster["surfaces"]
+        }
+        self.assertIn("atlas", by_id)
+        self.assertTrue(self.map["atlas_membership"]["included_in_surface_count"])
+        self.assertEqual(by_id["atlas"]["label"], "MODELED")
+        # `circuits` was added after the embedded Wave-27 label snapshot and its canonical
+        # title makes no maturity claim. The Atlas must not silently promote it.
+        self.assertEqual(by_id["circuits"]["label"], "UNSPECIFIED")
+
+    def test_brain_lens_is_read_only_and_reproducible_in_the_surface(self) -> None:
+        js = (Path(__file__).parents[1] / "static" / "3d" / "surfaces" / "atlas.js").read_text(encoding="utf-8")
+        self.assertIn("/api/a11oy/v1/brain/health", js)
+        self.assertIn("/api/a11oy/v1/brain/gaps", js)
+        self.assertIn("Purpose · Try · Evidence · Limits · Reproduce", js)
+        self.assertIn("no memory write, no model call, no action", js)
+        self.assertNotRegex(js, re.compile(r"fetch\([^\n]+method\s*:\s*[\"']POST", re.I))
+
+    def test_registry_module_aliases_resolve(self) -> None:
+        surface_dir = Path(__file__).parents[1] / "static" / "3d" / "surfaces"
+        for surface in szl3d_holographic.SURFACES:
+            module_id = surface.get("module", surface["id"])
+            self.assertTrue((surface_dir / (module_id + ".js")).is_file(), surface["id"])
+        markets = next(row for row in szl3d_holographic.SURFACES if row["id"] == "markets")
+        self.assertEqual(markets["module"], "finance")
+
+
+if __name__ == "__main__":
+    unittest.main()