Move anatomy to public creator profile (6e7f19a7b759)

.dockerignore

@@ -0,0 +1,5 @@
+.git
+.github
+__pycache__
+*.py[cod]
+tests

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# Solo-builder ownership
+* @stephenlutar2-hash

.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+  # GitHub Actions dependencies
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "08:00"
+      timezone: "America/New_York"
+    labels:
+      - "dependencies"
+      - "security"
+    open-pull-requests-limit: 5
+    groups:
+      # Group low-risk patch/minor bumps; major bumps arrive as separate PRs.
+      actions:
+        patterns:
+          - "*"
+        update-types:
+          - "minor"
+          - "patch"

.github/workflows/codeql.yml

@@ -0,0 +1,19 @@
+name: CodeQL
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '23 4 * * 1'  # Weekly Monday 04:23 UTC
+permissions:
+  contents: read
+jobs:
+  analyze:
+    uses: szl-holdings/.github/.github/workflows/reusable-codeql.yml@0c06506cba0f9d87f8bf25e37ebc1b53b3121523
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    with:
+      languages: '["javascript-typescript"]'

.github/workflows/container-contract.yml

@@ -0,0 +1,76 @@
+name: Container contract
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  container-contract:
+    name: Build and exercise source-bound Living Anatomy image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out source
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Materialize exact public Second Brain projection
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: python scripts/materialize_second_brain.py --output .runtime/second-brain
+
+      - name: Run server and Second Brain contract tests
+        run: python -m unittest discover -s tests -v
+
+      - name: Build pinned Space image
+        run: docker build --tag anatomy-space-ci .
+
+      - name: Start Space image
+        run: docker run --detach --name anatomy-space-ci --publish 7860:7860 anatomy-space-ci
+
+      - name: Verify combined live container contract
+        run: |
+          set -euo pipefail
+          for attempt in $(seq 1 30); do
+            if curl --fail --silent --show-error \
+              http://127.0.0.1:7860/api/anatomy/v1/living-health \
+              > living-health.json; then
+              curl --fail --silent --show-error \
+                "http://127.0.0.1:7860/api/anatomy/v1/brain/search?q=governed%20receipts&k=3" \
+                > brain-search.json
+              python - <<'PY'
+          import json
+
+          living = json.load(open("living-health.json", encoding="utf-8"))
+          search = json.load(open("brain-search.json", encoding="utf-8"))
+          assert living["ready"] is True
+          assert living["transport_state"] == "REACHABLE"
+          assert living["organs"]["brain"]["ready"] is True
+          assert living["organs"]["brain"]["chunk_count"] == 575
+          assert search["ready"] is True
+          assert search["handles"]
+          assert all("text" not in handle for handle in search["handles"])
+          assert all(len(handle["sha256"]) == 64 for handle in search["handles"])
+          PY
+              test "$(curl --silent --output /dev/null --write-out '%{http_code}' \
+                http://127.0.0.1:7860/this-route-must-not-exist)" = "404"
+              exit 0
+            fi
+            sleep 1
+          done
+          docker logs anatomy-space-ci
+          exit 1
+
+      - name: Stop Space image
+        if: always()
+        run: docker rm --force anatomy-space-ci || true

.github/workflows/hf-sync.yml

@@ -0,0 +1,402 @@
+# Copyright 2026 SZL Holdings — SPDX-License-Identifier: Apache-2.0
+name: Sync Living Anatomy to Hugging Face
+
+# GitHub is authoritative. This workflow materializes the exact public
+# szl-second-brain revision, validates it, mirrors the runtime whitelist to
+# betterwithage/anatomy, makes the Space public, restarts it when needed, and
+# verifies the source-bound live contracts. It never exports the private graph.
+
+on:
+  push:
+    branches: [main]
+  schedule:
+    - cron: "17 */6 * * *"
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+
+concurrency:
+  group: anatomy-hf-sync
+  cancel-in-progress: false
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - name: Checkout exact protected-main source
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.sha }}
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Install pinned Hugging Face client
+        run: python -m pip install --disable-pip-version-check --no-cache-dir "huggingface_hub==1.23.0"
+
+      - name: Materialize and validate exact Second Brain projection
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: python scripts/materialize_second_brain.py --output .runtime/second-brain
+
+      - name: Reconcile, mirror, and verify Living Anatomy
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          SPACE_ID: betterwithage/anatomy
+        run: |
+          set -euo pipefail
+          if [ -z "${HF_TOKEN:-}" ]; then
+            echo "::error::HF_TOKEN is not set; cannot reconcile betterwithage/anatomy."
+            exit 1
+          fi
+          python3 <<'PYEOF'
+          import glob
+          import json
+          import os
+          import time
+          import urllib.request
+          from pathlib import Path
+
+          from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download
+
+          api = HfApi(token=os.environ["HF_TOKEN"])
+          space = os.environ["SPACE_ID"]
+          source_revision = os.environ.get("GITHUB_SHA", "").lower()
+          source_ref = os.environ.get("GITHUB_REF")
+          workflow_run_id = os.environ.get("GITHUB_RUN_ID", "")
+          github_repo = os.environ.get("GITHUB_REPOSITORY")
+          github_token = os.environ.get("GITHUB_TOKEN", "")
+
+          if len(source_revision) != 40 or any(
+              character not in "0123456789abcdef" for character in source_revision
+          ):
+              raise RuntimeError("GITHUB_SHA is not an exact Git revision")
+          if source_ref != "refs/heads/main":
+              raise RuntimeError(
+                  f"refusing production deploy from non-main ref: {source_ref!r}"
+              )
+          if github_repo != "szl-holdings/anatomy":
+              raise RuntimeError(f"unexpected GitHub repository: {github_repo!r}")
+          if not workflow_run_id.isdigit():
+              raise RuntimeError("GITHUB_RUN_ID is not numeric")
+          if not github_token:
+              raise RuntimeError("GITHUB_TOKEN is unavailable")
+
+          request = urllib.request.Request(
+              os.environ.get("GITHUB_API_URL", "https://api.github.com").rstrip("/")
+              + f"/repos/{github_repo}/commits/main",
+              headers={
+                  "Accept": "application/vnd.github+json",
+                  "Authorization": f"Bearer {github_token}",
+                  "X-GitHub-Api-Version": "2022-11-28",
+                  "User-Agent": "szl-anatomy-hf-sync/2.0",
+              },
+          )
+          with urllib.request.urlopen(request, timeout=20) as response:
+              current_main = str(json.load(response).get("sha") or "").lower()
+          if current_main != source_revision:
+              raise RuntimeError(
+                  "refusing stale production deploy at mutation boundary: "
+                  f"current_main={current_main!r} source_revision={source_revision!r}"
+              )
+
+          brain_source_path = Path(".runtime/second-brain/source.json")
+          brain_source = json.loads(brain_source_path.read_text(encoding="utf-8"))
+          brain_revision = str(brain_source.get("source_revision") or "").lower()
+          if len(brain_revision) != 40:
+              raise RuntimeError("Second Brain snapshot lacks an exact source revision")
+          if int(brain_source.get("public_chunk_count") or 0) != 575:
+              raise RuntimeError(
+                  "Second Brain snapshot does not contain exactly 575 public chunks"
+              )
+          if brain_source.get("private_graph_nodes_materialized") != 0:
+              raise RuntimeError("private Second Brain nodes entered the public snapshot")
+
+          info = api.space_info(space)
+          if bool(getattr(info, "private", False)):
+              print("Promoting Space to public:", space)
+              api.update_repo_settings(
+                  repo_id=space,
+                  repo_type="space",
+                  private=False,
+              )
+              info = api.space_info(space)
+          if bool(getattr(info, "private", False)):
+              raise RuntimeError("Space remained private after public reconciliation")
+
+          def stage_name(runtime):
+              value = getattr(runtime, "stage", None)
+              return str(getattr(value, "value", value) or "UNKNOWN").upper()
+
+          initial_stage = stage_name(api.get_space_runtime(space))
+          if initial_stage in {
+              "PAUSED",
+              "SLEEPING",
+              "STOPPED",
+              "RUNTIME_ERROR",
+              "BUILD_ERROR",
+              "CONFIG_ERROR",
+          }:
+              print("Restarting Space from stage:", initial_stage)
+              api.restart_space(
+                  repo_id=space,
+                  factory_reboot=initial_stage
+                  in {"RUNTIME_ERROR", "BUILD_ERROR", "CONFIG_ERROR"},
+              )
+
+          def remote_json(path):
+              try:
+                  local = hf_hub_download(
+                      repo_id=space,
+                      repo_type="space",
+                      filename=path,
+                      token=os.environ["HF_TOKEN"],
+                      force_download=True,
+                  )
+                  return json.loads(Path(local).read_text(encoding="utf-8"))
+              except Exception as error:
+                  print("Remote metadata unavailable:", path, type(error).__name__)
+                  return {}
+
+          existing_deploy = remote_json("hf-deploy-manifest.json")
+          existing_brain = remote_json(".runtime/second-brain/source.json")
+          source_changed = existing_deploy.get("source_revision") != source_revision
+          brain_changed = (
+              existing_brain.get("source_revision") != brain_revision
+              or existing_brain.get("corpus_sha256")
+              != brain_source.get("corpus_sha256")
+          )
+          needs_commit = source_changed or brain_changed
+
+          target_sha = str(getattr(info, "sha", "") or "")
+          expected_workflow_run_id = str(
+              existing_deploy.get("workflow_run_id") or ""
+          )
+
+          if needs_commit:
+              patterns = [
+                  "README.md",
+                  "Dockerfile",
+                  ".dockerignore",
+                  "server.py",
+                  "organ_integrity.py",
+                  "living_runtime.py",
+                  "second_brain_runtime.py",
+                  "scripts/materialize_second_brain.py",
+                  ".runtime/**/*",
+                  "*.html",
+                  "*.js",
+                  "*.css",
+                  "lib/**/*",
+              ]
+              files = []
+              for pattern in patterns:
+                  files.extend(
+                      path
+                      for path in glob.glob(pattern, recursive=True)
+                      if os.path.isfile(path)
+                  )
+              files = sorted(set(files))
+              required = {
+                  "living_runtime.py",
+                  "second_brain_runtime.py",
+                  ".runtime/second-brain/manifest.json",
+                  ".runtime/second-brain/brain-corpus.public.jsonl",
+                  ".runtime/second-brain/source.json",
+              }
+              missing = sorted(required - set(files))
+              if missing:
+                  raise RuntimeError(
+                      f"required Living Anatomy runtime artifacts missing: {missing}"
+                  )
+
+              deploy_manifest = {
+                  "schema": "szl.hf-deploy-manifest/v1",
+                  "source_repository": "szl-holdings/anatomy",
+                  "source_revision": source_revision,
+                  "source_path": "",
+                  "destination": {
+                      "repo_id": space,
+                      "repo_type": "space",
+                      "mode": "runtime-whitelist",
+                      "visibility": "public",
+                      "lifecycle": "KEEP_PUBLIC_RUNNING",
+                  },
+                  "dependencies": {
+                      "second_brain": {
+                          "source_repository": brain_source["source_repository"],
+                          "source_revision": brain_revision,
+                          "public_chunk_count": brain_source["public_chunk_count"],
+                          "corpus_sha256": brain_source["corpus_sha256"],
+                          "authority_state": "READ_ONLY",
+                          "content_access": "HANDLES_ONLY",
+                      }
+                  },
+                  "workflow_run_id": workflow_run_id,
+              }
+              operations = []
+              for path in files:
+                  operations.append(
+                      CommitOperationAdd(path_in_repo=path, path_or_fileobj=path)
+                  )
+              operations.append(
+                  CommitOperationAdd(
+                      path_in_repo="hf-deploy-manifest.json",
+                      path_or_fileobj=(
+                          json.dumps(deploy_manifest, sort_keys=True, indent=2) + "\n"
+                      ).encode("utf-8"),
+                  )
+              )
+              print(
+                  "Syncing",
+                  len(operations),
+                  "source-bound artifacts to",
+                  space,
+                  "anatomy=",
+                  source_revision,
+                  "brain=",
+                  brain_revision,
+              )
+              commit = api.create_commit(
+                  repo_id=space,
+                  repo_type="space",
+                  operations=operations,
+                  commit_message=f"hf-sync: source {source_revision} run {workflow_run_id}",
+              )
+              target_sha = str(commit.oid)
+              expected_workflow_run_id = workflow_run_id
+          else:
+              print(
+                  "Source and Second Brain revisions already deployed; "
+                  "performing lifecycle and live-contract reconciliation only."
+              )
+              if not expected_workflow_run_id.isdigit():
+                  raise RuntimeError(
+                      "deployed manifest lacks a numeric workflow run identity"
+                  )
+              workflow_run_id = expected_workflow_run_id
+              info = api.space_info(space)
+              target_sha = str(getattr(info, "sha", "") or "")
+
+          if len(target_sha) != 40:
+              raise RuntimeError(f"target Hugging Face revision is invalid: {target_sha!r}")
+
+          deadline = time.monotonic() + 600
+          restarted = False
+          while time.monotonic() < deadline:
+              info = api.space_info(space)
+              runtime = api.get_space_runtime(space)
+              stage = stage_name(runtime)
+              current_sha = str(getattr(info, "sha", "") or "")
+              print("Observed Space:", current_sha, stage, "private=", info.private)
+              if bool(getattr(info, "private", False)):
+                  api.update_repo_settings(
+                      repo_id=space,
+                      repo_type="space",
+                      private=False,
+                  )
+              if (
+                  info.sha == target_sha
+                  and stage
+                  in {
+                      "PAUSED",
+                      "SLEEPING",
+                      "STOPPED",
+                      "RUNTIME_ERROR",
+                      "BUILD_ERROR",
+                      "CONFIG_ERROR",
+                  }
+                  and not restarted
+              ):
+                  api.restart_space(
+                      repo_id=space,
+                      factory_reboot=stage
+                      in {"RUNTIME_ERROR", "BUILD_ERROR", "CONFIG_ERROR"},
+                  )
+                  restarted = True
+              if info.sha == target_sha and stage == "RUNNING" and not info.private:
+                  break
+              time.sleep(10)
+          else:
+              raise TimeoutError(
+                  f"Space did not settle RUNNING/public at {target_sha} within 600 seconds"
+              )
+
+          base = "https://betterwithage-anatomy.hf.space"
+          for attempt in range(18):
+              try:
+                  def get_json(url, timeout=15):
+                      with urllib.request.urlopen(url, timeout=timeout) as response:
+                          return json.load(response)
+
+                  health = get_json(base + "/healthz")
+                  living = get_json(
+                      base + "/api/anatomy/v1/living-health?refresh=1"
+                  )
+                  brain = get_json(base + "/api/anatomy/v1/brain/health?refresh=1")
+                  search = get_json(
+                      base
+                      + "/api/anatomy/v1/brain/search"
+                      + "?q=governed%20receipts%20living%20anatomy&k=3"
+                  )
+                  version = get_json(base + "/version?refresh=1")
+                  evidence = get_json(base + "/evidence?refresh=1", timeout=20)
+                  source = get_json(
+                      base + "/.well-known/szl-source.json?refresh=1"
+                  )
+                  manifest = get_json(base + "/api/anatomy/v1/manifest")
+
+                  assert health["transport_state"] == "REACHABLE"
+                  assert health["verification_state"] == "STRUCTURAL_ONLY"
+                  assert living["ready"] is True
+                  assert living["organs"]["brain"]["chunk_count"] == 575
+                  assert brain["ready"] is True
+                  assert brain["state"] == "SOURCE_BOUND_PUBLIC_PROJECTION"
+                  assert brain["source_revision"] == brain_revision
+                  assert brain["chunk_count"] == 575
+                  assert brain["private_graph_nodes_loaded"] == 0
+                  assert brain["content_access"] == "HANDLES_ONLY"
+                  assert search["ready"] is True
+                  assert search["handles"]
+                  assert all("text" not in handle for handle in search["handles"])
+                  assert version["gitSha"] == source_revision
+                  assert version["deploymentRevision"] == target_sha
+                  assert version["secondBrainSourceRevision"] == brain_revision
+                  assert version["evidenceState"] == "MEASURED"
+                  assert evidence["gitSha"] == source_revision
+                  assert evidence["evidenceState"] == "PARTIAL"
+                  assert evidence["source"]["deployment"]["hf_revision"] == target_sha
+                  assert evidence["receipts"][0]["status"] == "STRUCTURAL_ONLY"
+                  assert evidence["outputProvenance"]["authenticityEstablished"] is False
+                  assert evidence["dependencies"]["secondBrain"]["ready"] is True
+                  assert source["deployment"]["hf_revision"] == target_sha
+                  assert source["source"]["commit"] == source_revision
+                  assert source["alignment_state"] == "SOURCE_BOUND_DEPLOYMENT"
+                  assert source["deployment"]["workflow_run_id"] == workflow_run_id
+                  assert (
+                      manifest["endpoints"]["brain_health"]
+                      == "/api/anatomy/v1/brain/health"
+                  )
+                  final_info = api.space_info(space)
+                  assert final_info.private is False
+                  print(
+                      "Verified Living Anatomy public/RUNNING:",
+                      target_sha,
+                      "Second Brain:",
+                      brain_revision,
+                  )
+                  break
+              except Exception as error:
+                  if attempt == 17:
+                      raise RuntimeError(
+                          "Public Living Anatomy + Second Brain verification failed"
+                      ) from error
+                  print("Live verification retry:", type(error).__name__, error)
+                  time.sleep(10)
+          PYEOF

.github/workflows/overclaim-guard.yml

@@ -0,0 +1,20 @@
+name: Doctrine Overclaim Guard
+
+# Grep-based honesty gate. The rule lives in ONE place — the org-shared
+# reusable workflow in szl-holdings/.github — so every repo that publishes
+# Λ-uniqueness / Conjecture-1 claims inherits the same check automatically.
+# Fails CI if a governed surface claims Λ uniqueness without the Theorem U /
+# U₁ / U₂ qualifier, or describes Conjecture 1 as proven/closed (it stays OPEN).
+on:
+  workflow_dispatch: {}
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  overclaim:
+    uses: szl-holdings/.github/.github/workflows/reusable-overclaim-guard.yml@464069d945b10e51893fc749f5530b7643f23ad4

.github/workflows/pin-check.yml

@@ -0,0 +1,20 @@
+name: Pin Check
+
+# Thin caller — delegates to the org-wide reusable SHA-pin check so this repo's
+# workflow files are validated identically to every other repo. The reusable is
+# pinned by commit SHA (the rule it enforces). See szl-holdings/.github
+# replit-sync/FORGE_UPGRADE_pincheck-orgwide.md.
+
+on:
+  push:
+    branches: [main]
+    paths: ['.github/workflows/**']
+  pull_request:
+    paths: ['.github/workflows/**']
+
+permissions:
+  contents: read
+
+jobs:
+  pin-check:
+    uses: szl-holdings/.github/.github/workflows/pin-check-reusable.yml@1bbd857634a87d3a824be86ec7a79aaa8e4937e8

.github/workflows/sbom.yml

@@ -0,0 +1,25 @@
+# Copyright 2026 SZL Holdings — SPDX-License-Identifier: Apache-2.0
+name: SBOM
+
+# Org reusable SBOM (CycloneDX + SPDX) gate (SHA-pinned caller). Wave G CI parity.
+on:
+  push:
+    branches: [main]
+  release:
+    types: [published]
+  workflow_dispatch:
+
+# reusable-sbom.yml runs a trivy-fs child job that uploads SARIF, which needs
+# security-events: write. A reusable job cannot exceed the caller's grant, so
+# without this the workflow is rejected at startup (startup_failure). actions:
+# read is required for the SARIF/code-scanning upload action.
+permissions:
+  contents: read
+
+jobs:
+  sbom:
+    permissions:
+      contents: write
+      security-events: write
+    uses: szl-holdings/.github/.github/workflows/reusable-sbom.yml@ebd2128c691b850c84438b671fbb512945933776
+    secrets: inherit

.github/workflows/scorecard.yml

@@ -0,0 +1,20 @@
+name: Scorecard
+on:
+  push:
+    branches: [main]
+  schedule:
+    - cron: '30 1 * * 6'  # Weekly Saturday 01:30 UTC
+# reusable-scorecard.yml requests security-events: write, id-token: write and
+# actions: read; a reusable job cannot exceed the caller's grant, so the caller
+# must grant at least these or the run is rejected at startup (startup_failure).
+permissions:
+  contents: read
+jobs:
+  scorecard:
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+      id-token: write
+    uses: szl-holdings/.github/.github/workflows/reusable-scorecard.yml@0c06506cba0f9d87f8bf25e37ebc1b53b3121523
+    secrets: inherit

.github/workflows/trivy.yml

@@ -0,0 +1,20 @@
+name: Trivy
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+  schedule:
+    - cron: '0 6 * * 1'  # Weekly Monday 06:00 UTC
+# reusable-trivy.yml uploads a SARIF report to code-scanning, which needs
+# security-events: write. A reusable job cannot exceed the caller's grant, so
+# without this the run is rejected at startup (startup_failure).
+permissions:
+  contents: read
+jobs:
+  trivy:
+    permissions:
+      contents: read
+      security-events: write
+    uses: szl-holdings/.github/.github/workflows/reusable-trivy.yml@0c06506cba0f9d87f8bf25e37ebc1b53b3121523
+    secrets: inherit

.gitignore

@@ -0,0 +1,23 @@
+# SZL Living Anatomy — static SDK Space (no build step). Keep the tree clean:
+# the only things that should ever land here are the vendored bundle + sources.
+
+# local QA harness (qa_yarqa.js runs under Playwright/Chromium, installed locally)
+node_modules/
+package-lock.json
+qa_*_results.json
+qa_*.png
+
+# python tooling cruft (if a contributor runs scans/linters locally)
+__pycache__/
+*.pyc
+.pytest_cache/
+
+# environment / secrets — never commit
+.env
+.env.*
+
+# editor / OS noise
+.DS_Store
+*.swp
+.idea/
+.vscode/

.runtime/second-brain/manifest.json

@@ -0,0 +1,20 @@
+{
+  "datasetName": "SZL Second Brain — in-repo lane (public projection)",
+  "doctrine": "Public projection of the IN-REPO lane of the SZL Second Brain. It is DATA, not a model — a retrieval corpus, never weights. Built deterministically from repo-public text (curated docs, the 269-entry formula corpus, DECLARED ingest takeaways, and the DECLARED Ouroboros invariant codex — definitions only, never live check status). The owner-infrastructure ops doc (OWNER-SETUP.md) is EXCLUDED from this public projection, though it remains in the app-served corpus. A BM25 / similarity score over these chunks ranks lexical overlap; it is NEVER correctness. This is wholly separate from the owner's private Brain, which is never published. Nothing here trains a model, evaluates one, serves inference, or upgrades Λ (Conjecture-1).",
+  "supersetChunkCount": 581,
+  "supersetCorpusSha256": "04e037b7ccf3bb0f4e54d2cbcda59a833277277f99f7726224e8f9a009603a7d",
+  "publicChunkCount": 575,
+  "bySource": {
+    "doc": 152,
+    "formula": 269,
+    "ingest": 143,
+    "invariant": 11
+  },
+  "excludedSourceIds": [
+    "OWNER-SETUP.md"
+  ],
+  "excludedChunkCount": 6,
+  "projectionSha256": "d02487523b451b390125bc3c0a20e259c44b5715528fac69cf789ca56755ea10",
+  "secretScan": "PASS",
+  "secretScanPatternCount": 7
+}

.runtime/second-brain/source.json

@@ -0,0 +1,27 @@
+{
+  "authority_state": "READ_ONLY",
+  "by_source": {
+    "doc": 152,
+    "formula": 269,
+    "ingest": 143,
+    "invariant": 11
+  },
+  "canonical_dataset": "SZLHOLDINGS/szl-second-brain-inrepo",
+  "content_access": "HANDLES_ONLY",
+  "corpus_path": "data/brain-corpus.public.jsonl",
+  "corpus_sha256": "387337acbd8fe443637102fe7ea75387fa4c3d9d746d8ab6e2d14d6c138aad8f",
+  "lambda_state": "CONJECTURE_1",
+  "manifest_path": "data/manifest.json",
+  "manifest_projection_sha256": "d02487523b451b390125bc3c0a20e259c44b5715528fac69cf789ca56755ea10",
+  "manifest_sha256": "7a2816331df3c7356b5cb01605ea108fa98bb4503d401d3b2952e6b65145d02e",
+  "materialized_at": "2026-09-04T00:12:24Z",
+  "private_graph_nodes_materialized": 0,
+  "public_chunk_count": 575,
+  "raw_graph_nodes_admitted_to_gradients": 0,
+  "schema": "szl.second-brain.snapshot/v1",
+  "secret_scan": "PASS",
+  "source_ref": "main",
+  "source_relation": "github-exact-revision-public-projection",
+  "source_repository": "szl-holdings/szl-second-brain",
+  "source_revision": "ff03b116a83f2b5302999ab4167d51e35aba3b5e"
+}

Dockerfile

@@ -0,0 +1,11 @@
+# Unified Python runtime for SZL Living Anatomy + YACHAY Second Brain.
+# The 3D bundle stays vendored and zero-CDN. living_runtime.py extends the
+# existing hardened server in-process with a source-bound, handles-only Brain
+# organ; no private graph, model weights, or write authority enter the image.
+FROM mirror.gcr.io/library/python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
+WORKDIR /app
+COPY . /app
+EXPOSE 7860
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:7860/api/anatomy/v1/living-health', timeout=2).read()"
+CMD ["python", "living_runtime.py"]

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MIGRATION_RECEIPT.json

@@ -0,0 +1,281 @@
+{
+  "bytes": 2147752,
+  "captured_at": "2026-09-04T00:12:23+00:00",
+  "destination": "betterwithage/anatomy",
+  "file_count": 54,
+  "files": [
+    {
+      "bytes": 41,
+      "path": ".dockerignore",
+      "sha256": "c127c358bafd75d851bce6f1f8872097484341cbdf124a2c108abd8973d2f33c"
+    },
+    {
+      "bytes": 1519,
+      "path": "__gitattributes__.txt",
+      "sha256": "11ad7efa24975ee4b0c3c3a38ed18737f0658a5f75a0a96787b576a78a023361"
+    },
+    {
+      "bytes": 47,
+      "path": ".github/CODEOWNERS",
+      "sha256": "49928138e716b8da4f215977f36d12b3fd1432353c845525302f201dd8d455ce"
+    },
+    {
+      "bytes": 512,
+      "path": ".github/dependabot.yml",
+      "sha256": "c6442e73c663d9d9a632f49517eb59b7ac119c3b4b6f18fa335b5b9b583d86b3"
+    },
+    {
+      "bytes": 446,
+      "path": ".github/workflows/codeql.yml",
+      "sha256": "4d69057eef7d35ccfdd7045725d3bb37a8f9b0e5e4d24f0e95ac924872307bc1"
+    },
+    {
+      "bytes": 2664,
+      "path": ".github/workflows/container-contract.yml",
+      "sha256": "0dd4351bae91d5ebda0ae45b209cd7937c6a612866dd84406f7f3c2e31b4f352"
+    },
+    {
+      "bytes": 17154,
+      "path": ".github/workflows/hf-sync.yml",
+      "sha256": "3943f8329ded8f8d9e9f23b39da59c93b5d4dda383b1481453ed5a6e7ec438f9"
+    },
+    {
+      "bytes": 727,
+      "path": ".github/workflows/overclaim-guard.yml",
+      "sha256": "5d8b1fcf929d5e389a3248f5f7e44f29826b7bb383b3870fee1a9c4eff8562b3"
+    },
+    {
+      "bytes": 586,
+      "path": ".github/workflows/pin-check.yml",
+      "sha256": "0e1411b8ab7763193b09a76a33bffb235e26cf08d54d20130f492730e3e7f0f6"
+    },
+    {
+      "bytes": 793,
+      "path": ".github/workflows/sbom.yml",
+      "sha256": "4fdda15e803abe906d63833bfd5755e0f0c0384f22962f896eb1e46efb607dbc"
+    },
+    {
+      "bytes": 646,
+      "path": ".github/workflows/scorecard.yml",
+      "sha256": "e400aec0da60fa7bd46f63eef9de69dd08720f6bc9881159fbcfb8f518d8e9ca"
+    },
+    {
+      "bytes": 604,
+      "path": ".github/workflows/trivy.yml",
+      "sha256": "ec8274072beebd9c790051601a812abe2ab2d0e8ca320a755f47bb07e45a5574"
+    },
+    {
+      "bytes": 514,
+      "path": ".gitignore",
+      "sha256": "b9cd89d84215280b3a7a8caa15fb5ea78c1f0faef8510ddf9e57fc0f92f80256"
+    },
+    {
+      "bytes": 551172,
+      "path": ".runtime/second-brain/brain-corpus.public.jsonl",
+      "sha256": "387337acbd8fe443637102fe7ea75387fa4c3d9d746d8ab6e2d14d6c138aad8f"
+    },
+    {
+      "bytes": 1300,
+      "path": ".runtime/second-brain/manifest.json",
+      "sha256": "7a2816331df3c7356b5cb01605ea108fa98bb4503d401d3b2952e6b65145d02e"
+    },
+    {
+      "bytes": 1073,
+      "path": ".runtime/second-brain/source.json",
+      "sha256": "dc577fee39f76d5f938130c8219b98e2373716791800386dd25f7ffb864938c0"
+    },
+    {
+      "bytes": 699,
+      "path": "Dockerfile",
+      "sha256": "cee5bf78f6de5f491bc52ae83a63bce1ea95f08fc9aaec104ccc22a61dbe0094"
+    },
+    {
+      "bytes": 11358,
+      "path": "LICENSE",
+      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    },
+    {
+      "bytes": 24596,
+      "path": "README.md",
+      "sha256": "58014ac91800b906543e396427fcf386b329d5417a67733c2f066a379be45634"
+    },
+    {
+      "bytes": 7057,
+      "path": "SCREENSHOT_NOTES.md",
+      "sha256": "2c9897400e12cd73d3033aa339d85f73942eebcbdc35480438e37b6f5f97cebe"
+    },
+    {
+      "bytes": 2023,
+      "path": "SECURITY.md",
+      "sha256": "cfd5c7cf11f5d950a7187a4781ee38c678dad16b471babc45b4a26895c7c935a"
+    },
+    {
+      "bytes": 183197,
+      "path": "app.js",
+      "sha256": "8a142f99d72f732f209ead306a68169448ce993179904703ff4616e487ceba8a"
+    },
+    {
+      "bytes": 23953,
+      "path": "covenant-cockpit.html",
+      "sha256": "554177f668b6a1c7d13a3a76b9eae2424056e1510523532798c97f544c510ecb"
+    },
+    {
+      "bytes": 13968,
+      "path": "covenant-cockpit.js",
+      "sha256": "1979e6b92ddf4877c4cfdb19b71fc06523b8ad715a48883295ecb40fc1bf14b8"
+    },
+    {
+      "bytes": 98455,
+      "path": "data.js",
+      "sha256": "067e3b8181cfce4b8c1854d2541077d1702d596815bcefa01d9e6c4ecd10b7df"
+    },
+    {
+      "bytes": 3211,
+      "path": "docs/LIVING_ANATOMY_SECOND_BRAIN.md",
+      "sha256": "e94eda4f1fa4bac8bf0f6e25b4ce58837b4dec315207a941f57fc5764986e6b6"
+    },
+    {
+      "bytes": 872,
+      "path": "docs/holographic-space-v2.md",
+      "sha256": "829858aa28c37795480497301790dfc57cc783013b1427e2c54a06eee84b0726"
+    },
+    {
+      "bytes": 390,
+      "path": "favicon.svg",
+      "sha256": "9840fd2ad356862d4c2ed262171841108ef25b667bcfd00334611b7a3441e2e2"
+    },
+    {
+      "bytes": 24759,
+      "path": "frontier_anatomy.js",
+      "sha256": "44ecde4c8e15e7ea2cb2e810cb374280e394b87e6815c1eef41f435450143629"
+    },
+    {
+      "bytes": 780,
+      "path": "hf-deploy-manifest.json",
+      "sha256": "7a0173cfadf6e21cc12b73b31faaf0ce10373343a66c6242bb79a8dd4890cd61"
+    },
+    {
+      "bytes": 140206,
+      "path": "index.html",
+      "sha256": "ccd537b8a7119cd72c350b25b682881a7cc1b12052e01b0ec10139b70ca66e30"
+    },
+    {
+      "bytes": 12272,
+      "path": "lib/szl_verify_widget.js",
+      "sha256": "b349aec4d6c19265d701b1b82fd1b24ba1d92f8821fa790da0ebe3b69f049609"
+    },
+    {
+      "bytes": 669884,
+      "path": "lib/three.min.js",
+      "sha256": "170c6789f43217c96b3170f4b42fafe135de7f7cd48497a4218f9757ee1d49fa"
+    },
+    {
+      "bytes": 28209,
+      "path": "live-body.html",
+      "sha256": "56541caf11a82fbde702724d9f29a859a7a6756aac8e217efa96d07d4ac5e3dd"
+    },
+    {
+      "bytes": 14349,
+      "path": "live-body.js",
+      "sha256": "b6fff49db582d2417be1c66617dbbb728bafc97ee91ddbce2eca0d90f5c6e0ad"
+    },
+    {
+      "bytes": 13549,
+      "path": "living_runtime.py",
+      "sha256": "a05a170b20173ada173df4ed0cede0a7ad9fe3a2a4dc16cc93784009e7685e4a"
+    },
+    {
+      "bytes": 42987,
+      "path": "og-card.png",
+      "sha256": "bb249b5f3fca5aff6e4b8b9dd3ee2fda064773553a1e973d8f58d60aa63f007d"
+    },
+    {
+      "bytes": 19826,
+      "path": "organ_integrity.py",
+      "sha256": "b2816251df8d049f0b170b0a8dbfacd743ce2bd0f785aaa3157d44e386f4e078"
+    },
+    {
+      "bytes": 6666,
+      "path": "qa_cockpit.mjs",
+      "sha256": "25cd6265502433e56c74612b4a9bc82ce26d43948718a4e36a24174483eb37cc"
+    },
+    {
+      "bytes": 5338,
+      "path": "qa_yarqa.js",
+      "sha256": "2ea7e52d163e11fc488b4a565dba9ed49143fd60ab6f4ae708014715b5de2a07"
+    },
+    {
+      "bytes": 12094,
+      "path": "receipts.sample.json",
+      "sha256": "52bc6ae04d949495c129bf08c8483d37e6c7d100b537d09a1f1b0becdf1a661d"
+    },
+    {
+      "bytes": 9265,
+      "path": "scripts/materialize_second_brain.py",
+      "sha256": "76efdc311f84a2b2567ff6064fcf6c54027075d15983142612e441bc5297f749"
+    },
+    {
+      "bytes": 16194,
+      "path": "second_brain_runtime.py",
+      "sha256": "1af54925b974827d7c1c03cc7eb7801b165be7f86c3aef8a58c7de2d05fa8276"
+    },
+    {
+      "bytes": 46062,
+      "path": "server.py",
+      "sha256": "b5c9cee69cbfd7cac061092f2f49ae0f7dc0be6bf22703b7d34a7d49348d0365"
+    },
+    {
+      "bytes": 388,
+      "path": "style.css",
+      "sha256": "789bfd541c9f06658ac410d968e9c39fa8c63a48a08643b36071b984c699a9f4"
+    },
+    {
+      "bytes": 24190,
+      "path": "szl-holo-v2.css",
+      "sha256": "f295e29c659cc106c4443c5c20e559a3f49116b87307b9bd490e218647ee63a2"
+    },
+    {
+      "bytes": 15986,
+      "path": "szl-holo-v2.js",
+      "sha256": "c04597e6313acfafa471d30ae2948f692cd4f297560024d8979fe4cef1325450"
+    },
+    {
+      "bytes": 6104,
+      "path": "tests/qa_evidence_bay.js",
+      "sha256": "c2f2e1e0d95e5c373b57624cc35d4beaed98638ac1574b3ed4d3c4bbe48451b5"
+    },
+    {
+      "bytes": 5346,
+      "path": "tests/test_hf_sync_contract.py",
+      "sha256": "b9c963c9bab31b4accb4cd6865d4c4a168d57081a83733e8922882837f1d7fd2"
+    },
+    {
+      "bytes": 4790,
+      "path": "tests/test_second_brain_runtime.py",
+      "sha256": "8b7714a3d8bf6b1911f4a2f9927598dd3e711dcf64d180f589a44e16a8810208"
+    },
+    {
+      "bytes": 26720,
+      "path": "tests/test_server_contract.py",
+      "sha256": "e9aa968f27dee4abcfaaecddd6d0fc42844ff36232d08ce8f21ba7c5ebe36e0c"
+    },
+    {
+      "bytes": 28033,
+      "path": "v5_organs.js",
+      "sha256": "0ef1f09bf273ae5a6269ba32ec9e03cab93bca4bab56a1f1fe21ac60fd3873bc"
+    },
+    {
+      "bytes": 13405,
+      "path": "v6_alive.js",
+      "sha256": "65ee3306ff732d4d977ecec5014431e832c599900459c7016593d1f84010d380"
+    },
+    {
+      "bytes": 10773,
+      "path": "yachay-second-brain.js",
+      "sha256": "473d3f09b49e8069d64cd63a79bf5e3e0a17c9e299cd33c87b8169b9c19ba3f5"
+    }
+  ],
+  "source": "https://github.com/szl-holdings/anatomy.git",
+  "source_sha": "6e7f19a7b7597c618df52fffd5b1812d1e8a82c5",
+  "unresolved_lfs": []
+}

README.md

@@ -1,10 +1,389 @@
 ---
-title: Anatomy
-emoji: 🦀
-colorFrom: yellow
-colorTo: pink
+title: SZL Living Anatomy
+emoji: 🫀
+thumbnail: "https://huggingface.co/spaces/betterwithage/anatomy/resolve/main/og-card.png"
+colorFrom: blue
+colorTo: gray
 sdk: docker
+app_port: 7860
 pinned: false
+license: apache-2.0
+short_description: 3D navigable map of the governed-AI organ substrate
+tags:
+  - visualization
+  - threejs
+  - governance
+  - receipts
+  - honest-by-design
+  - szl-holdings
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<!-- SZL-ESTATE-CARD:v2:START -->
+<p align="center"><a href="https://a-11-oy.com/"><img src="https://huggingface.co/spaces/SZLHOLDINGS/README/resolve/main/assets/estate-banner-v2.svg" alt="SZL Holdings — governed, receipted, verifiable" width="100%"></a></p>
+<p align="center">
+  <a href="https://github.com/szl-holdings/.github/tree/main/doctrine"><img src="https://img.shields.io/badge/doctrine-v11%20LOCKED-0B1F3A?style=flat-square" alt="doctrine v11"></a>
+  <a href="https://a-11-oy.com/"><img src="https://img.shields.io/badge/evidence%20wall-LIVE%20%C2%B7%20verify%20in%20browser-3AF4C8?style=flat-square" alt="live evidence wall"></a>
+  <a href="https://huggingface.co/datasets/SZLHOLDINGS/szl-lake"><img src="https://img.shields.io/badge/szl--lake-offline%20verifiable-C9B787?style=flat-square" alt="szl-lake offline verifiable"></a>
+  <a href="https://huggingface.co/spaces/SZLHOLDINGS/holographic"><img src="https://img.shields.io/badge/estate%20map-holographic-5B8DEE?style=flat-square" alt="holographic estate map"></a>
+</p>
+<p align="center"><sub>Part of the <a href="https://huggingface.co/SZLHOLDINGS">SZL Holdings</a> governed estate — claims are designed to carry checkable receipts. Verification proves integrity &amp; origin, never accuracy or performance.</sub></p>
+<!-- SZL-ESTATE-CARD:v2:END -->
+
+# SZL Living Anatomy 🫀
+
+> **Governed AI you can prove — as a living body.**
+> A 3D, navigable map of the governed organism: its organs, how a single decision
+> flows through them, and where each proof and conjecture honestly sits.
+
+> **The living substrate · 5 systems · Λ heart · DSSE Khipu receipt bus · honest by design**
+>
+> **Shared, embeddable 3D scene** — rendered inside the a11oy and killinchu consoles; a visualization component, not a separate governance console.
+
+[![SLSA L1 honest (static viz)](https://img.shields.io/badge/SLSA-L1%20honest%20(static%20viz)-c9b787?style=flat-square)](https://github.com/szl-holdings/anatomy/actions/workflows/hf-sync.yml)
+[![doctrine-v11](https://img.shields.io/badge/doctrine-v11%20LOCKED-0B1F3A?style=flat-square)](https://github.com/szl-holdings/.github/tree/main/doctrine)
+[![License](https://img.shields.io/badge/license-Apache--2.0-5fb3a3?style=flat-square)](https://github.com/szl-holdings/anatomy)
+[![Λ Conjecture 1](https://img.shields.io/badge/%CE%9B-Conjecture%201-7d8aa0?style=flat-square)](https://github.com/szl-holdings/lutar-lean/blob/main/BOUNTY.md)
+[![Khipu Conjecture 2](https://img.shields.io/badge/Khipu%20BFT-Conjecture%202-7d8aa0?style=flat-square)](https://github.com/szl-holdings/khipu-consensus)
+
+The governed-AI organ substrate shared by **a11oy** (governed-AI command body) and
+**killinchu** (maritime / drone C2 body): two bodies, one circulatory + nervous mesh,
+with the Λ heart at the center.
+
+## Live integrity kernel (szl-khipu)
+
+This repository is the **3D atlas** (SLSA L1 static viz). The fail-closed organ-integrity
+kernel that actually runs the five organs lives in
+[szl-holdings/szl-khipu](https://github.com/szl-holdings/szl-khipu) as `evaluate_anatomy`,
+and on the KHIPU Space **Anatomy** tab:
+[SZLHOLDINGS/szl-khipu](https://huggingface.co/spaces/SZLHOLDINGS/szl-khipu).
+The command body exposes the same fail-closed contract at
+[`GET/POST /api/a11oy/v1/organs/integrity`](https://a-11-oy.com/api/a11oy/v1/organs/integrity)
+and the Evidence Bay at [szl-holdings/szl-organ-integrity](https://github.com/szl-holdings/szl-organ-integrity).
+
+HEART/YUYAY · YAWAR · YACHAY · OTel · Khipu skeleton. Any DOWN organ or a WILLAY veto
+blocks the body. Λ = Conjecture 1 OPEN. Energy UNAVAILABLE. Locked-proven stays 8.
+Not a Three.js rehost of this Space — the other way around: this Space is the map,
+szl-khipu is the kernel.
+
+## Evidence Bay — the proof boundary
+
+The 3D organism now has a machine-readable evidence boundary without replacing its
+visual language. Open **Evidence Bay** from the atlas to inspect every major surface
+through the same five-part contract: **Purpose · Try · Evidence · Limits · Reproduce**.
+
+- Transport, evidence, verification, and authority are separate dimensions. A
+  `RUNNING` Space is not treated as proof of model quality, freshness, or safety.
+- The deployed bundle emits a deterministic SHA-256 integrity receipt. Its local
+  verifier recomputes every declared file and deliberately returns
+  `STRUCTURAL-ONLY` because the public visualization has no signing key.
+- Live A11OY, Killinchu, and receipt-verifier dependencies are probed separately
+  and timestamped. Missing contracts stay `MISSING` or `UNAVAILABLE`; no green is
+  synthesized from an unrelated endpoint.
+- Formula claims link to their source files. This Space presents a declared
+  snapshot—it does not run Lean—and Λ remains Conjecture 1.
+- `/.well-known/szl-source.json` exposes the declared GitHub base, measured HF
+  revision, artifact-set digest, and the remaining GitHub-sync state. Automated
+  deployments add `hf-deploy-manifest.json`, binding the served runtime
+  whitelist to the exact current protected-main commit rechecked immediately
+  before publication; this is a source-bound deployment claim, not a
+  whole-repository byte-parity claim.
+
+## v6 — alive-proof layer (ratchet 2026-07-21)
+
+The **⛬ alive-proof (v6)** control closes the loop between the map and the
+running substrate. It fetches the latest anatomy alive-harness run from the
+restored public sink ([`SZLHOLDINGS/test-results`](https://huggingface.co/datasets/SZLHOLDINGS/test-results)),
+verifies the run's DSSE (PAE v1) ECDSA-P256 signature **in the browser**
+against the pinned, committed org key
+([`hatun-mcp/PUBKEY_szlholdings-ec-p256.pem`](https://github.com/szl-holdings/hatun-mcp/blob/main/PUBKEY_szlholdings-ec-p256.pem)),
+and only then displays the run — verdict, live assertion counts, per-layer
+results, and the formula-gate pass rate, all **derived from the signed
+evidence**, never hand-typed. Runs are signed by the live Hatun MCP gateway
+(`dsse_sign`, keyid `szlholdings-ec-p256`) and published by a fail-closed
+publisher that verifies before and after upload. If the sink is unreachable or
+a signature fails, the panel says so — no fabricated green light. A signed
+GREEN run proves liveness, not doctrine upgrades: locked-proven stays exactly
+8 and Λ remains Conjecture 1.
+
+Machine-readable routes:
+
+| Route | Meaning |
+|---|---|
+| `/version` | Exact GitHub source and deployed HF revision (`MEASURED` only when source-bound) |
+| `/evidence` | Release identity, structural bundle receipt, and dependency evidence index |
+| `/api/anatomy/v1/manifest` | Contract, state vocabulary, doctrine boundary |
+| `/api/anatomy/v1/capabilities` | Five-part capability shell and provenance |
+| `/api/anatomy/v1/evidence?refresh=1` | Fresh dependency contract probes |
+| `/api/anatomy/v1/receipt` | Deterministic local artifact receipt |
+| `POST /api/anatomy/v1/verify/receipt` | Replay local integrity; structural only |
+| `/.well-known/szl-source.json` | GitHub ↔ HF deployment-source attestation |
+
+## What's new in v5 — conscience, sovereign mesh, verifiable receipts (evolves v4)
+
+v5 **evolves** v4 (it does not replace it): the entire v4 engine (`data.js` / `app.js`,
+dissection dock, live-body, yarqa CFD) is preserved. A single additive module
+(`v5_organs.js`, same vendored-free / 0-CDN / no-build posture) layers on six new,
+honestly-labeled capabilities — all read-only against the live a11oy origin:
+
+- **WILLAY — conscience / immune-gate organ (NEW).** Five **inspectable** signed-refusal
+  classifiers (cyber · bio dual-use · hidden-reasoning extraction · prompt-injection /
+  governance bypass · self-harm), trust ceiling 0.97, read live from
+  `/api/a11oy/v1/willay/classifiers`. Honest label: refusals are **tamper-EVIDENT, not
+  tamper-proof** — auditable rules, the inverse of a removed/hidden classifier.
+- **Sovereign Mesh — circulatory upgrade.** Per-node up/**DOWN** read live from
+  `/api/a11oy/v1/govern/health` — a node that is offline reads DOWN, **never a fabricated
+  green light**. F11 Ayni reciprocity per node; **VRAM-fusion is ROADMAP** (the mesh is a
+  scheduler / router today).
+- **Buyer-verifiable receipt in-scene.** A "Verify offline" action reuses Tier-1 **WebCrypto
+  ECDSA-P256-SHA256** over the DSSE PAE against `/cosign.pub` — verified entirely in your
+  browser, no trust in us required. Plus a live **receipt bloodstream** counter reading the
+  unified ledger (`/api/lake/v1/health`: `total_receipts`, `sha3_256` chain head).
+- **8 locked-proven → organ map.** F1→BRAIN, F4+F11→HEART, F7+F22→CIRCULATORY, F12→NERVOUS,
+  F18+F19→SKELETON — each showing the verbatim Lean statement + `#print axioms`,
+  **kernel-verified sorry-free @ c7c0ba17**. Λ is the heart-gate: **advisory, Conjecture 1**,
+  never a theorem. Khipu BFT = Conjecture 2.
+- **AI-Assurance (WDP / CDAO) overlay.** Maps each organ to the assurance artifact it
+  satisfies (model card · data card · SBOM/SLSA · SI-7 hash-chain · TEVV signed receipt ·
+  OTel-GenAI) with honest **LIVE / PARTIAL / ROADMAP** status chips; links the live
+  `/assurance` surface.
+- **yarqa CFD + thermal-PINN physics layer.** Composes the existing yarqa plug-flow
+  compartmentalization with a thermal physics-informed-NN surrogate into one
+  "physics-governed" layer, labeled **MODELED** (not measured), bounded error. Never a locked
+  theorem; never folded into the locked-8.
+- **GPU-Sovereign Stack — SUBSTRATE (NEW).** The *vertical* compute anatomy that complements the
+  horizontal Sovereign Mesh: owned GPU fabric → runtime → mesh / router → open-weight model →
+  native governance → buyer-verifiable receipts. Framed against how the leaders present sovereign
+  compute (chip → cloud → model), made our own by promoting governance and verifiable receipts to
+  first-class layers. Every layer carries an honest posture chip; live layers read
+  `/govern/health` and degrade to **DOWN**, never a fabricated green light. Energy is **SAMPLE**
+  until a real NVML meter; VRAM-fusion and on-metal **TEE attestation are ROADMAP**. Adds nothing
+  to the locked-8.
+
+Locked-proven stays **exactly 8** {F1,F4,F7,F11,F12,F18,F19,F22} @ `c7c0ba17`; the doctrine
+footer is unchanged. Still sovereign: ONLY the vendored `lib/three.min.js`, zero runtime CDN.
+
+## What's new in v4 — dissection tools
+
+v4 **evolves** v3 (it does not replace it): the entire v3 engine, organs, formulas,
+YAWAR receipt bus, GPD lens, and text fallback are preserved. Layered on top are
+bench-grade dissection controls so the body is *easier to dissect*:
+
+- **Dissection layer stack** — toggle + opacity-slide the conceptual layers
+  (circulatory · nervous · organs · skeleton/Khipu · halos/glow); choices persist in `localStorage`.
+- **Clip-plane scalpel** — a sliding X/Y/Z cross-section (`renderer.localClippingEnabled`)
+  cuts the organism so you can see the interior, with a reset.
+- **Explode view** — an eased 0→1 slider separates the organ groups radially for inspection.
+- **Search / jump** — filter organs + formulas by name/id; selecting one flies the camera and opens its panel.
+- **Always-on visibility HUD** — a compact overlay reading **honest** counts straight from
+  `data.js` (`D.KERNEL`): locked-proven = 8, experimental tier, axioms 14, sorries 163,
+  kernel `c7c0ba17`, Λ = Conjecture 1, Khipu BFT = Conjecture 2. Never hardcoded.
+- **Focus mode** — fade the other organs when one is selected, to isolate it.
+- **yarqa flow compartments (CFD) — additive, off by default** — an *engineering-method*
+  layer in the dissection dock that runs a clean-room plug-flow compartmentalization
+  (`yarqa`) over the **existing** circulatory / YAWAR flow sampled from `data.js`, draws
+  the compartments as a toggleable read-only overlay, and emits a reproducible integrity
+  receipt digest. It is **labeled CFD, not a locked theorem, and is never counted among
+  the locked 8** — `data.js` stays the single source of truth and the locked-proven count
+  is unchanged at 8.
+- **Accessibility + mobile** — every new control is keyboard-reachable and ARIA-labeled,
+  laid out so it never overlaps the existing HUD/panel, and it respects `prefers-reduced-motion`.
+
+Still sovereign: ONLY the vendored `lib/three.min.js` (THREE r160 global) — zero runtime
+CDN, no npm, no build step. The site stays a static, offline-capable bundle.
+
+## What you'll see
+
+Walk the organism in 3D and watch a real decision propagate: a request enters, the
+**YUYAY** gate scores it on 13 conjunctive axes (deny-by-default), the verdict is sealed
+into a **DSSE Khipu receipt** on the **YAWAR** append-only bus, and the **YACHAY** read-only
+cortex supplies reasoning without ever holding write authority. Each organ is labeled with
+its honest proof state — proven, conditional, or open conjecture — so nothing is dressed up
+as more certain than it is.
+
+**Five systems:** HEART · YUYAY (13-axis conjunctive critique gate, emits Λ-signed receipt) ·
+CIRCULATORY/BLOOD · YAWAR (append-only SHA-256 receipt bus) ·
+BRAIN · YACHAY (read-only reasoning cortex) ·
+NERVOUS · OTel/VSP · SKELETON · 12 service repos.
+
+**Honest doctrine:** locked-proven = 8 {F1, F4, F7, F11, F12, F18, F19, F22} @ kernel `c7c0ba17`
+(the no-axiom theorem `locked_count_eight`; F4 Khipu DAG acyclicity, F7 Chaski FIFO ordering,
+F22 Khipu emit append-only monotonicity) ·
+Λ unconditional uniqueness = Conjecture 1 (machine-checked FALSE); conditional Λ axiom-free PROVEN ·
+Khipu BFT safety = Conjecture 2, with the Wave23 conditional agreement theorem
+(`khipu_quorum_safety_conditional`, n≥3f+1 + honest non-equivocation, axiom-clean) ·
+~185 experimental CI-green · trust never 100% · no AGI.
+
+**Supply-chain posture:** this Space is a fully static visualization served by a thin
+Docker wrapper (`sdk: docker`; a static file server, no application backend) — SLSA L1 honest.
+The product images it depicts (**a11oy**, **killinchu**) are **SLSA L1 honest · L2 build-attested**
+(container provenance via attest-build-provenance, Sigstore keyless, Rekor-anchored; L3 roadmap) —
+see the active canonical successors [a11oy](https://github.com/szl-holdings/a11oy),
+[killinchu](https://github.com/szl-holdings/killinchu), and
+[szl-mesh](https://github.com/szl-holdings/szl-mesh).
+
+> **Non-affiliation.** SZL Holdings' use of "UDS" references Defense Unicorns' Unified Defense
+> Stack (USPTO Serial 99831122); SZL Holdings is not affiliated with Defense Unicorns. No
+> production ATO is claimed.
+
+## Live body view — `live-body.html`
+
+A new, **additive** page (`live-body.html` + `live-body.js`, linked from the
+title bar of the 3D atlas) turns the anatomy into the **LIVE BODY VIEW of the
+agentic GPU mind**. It is a standalone static page — same vendored-free,
+no-build, no-CDN posture as `index.html` — reachable directly at
+`…static.hf.space/live-body.html`. It does **not** modify the 3D engine (`app.js`,
+`data.js`), so there are no breaking changes.
+
+Each of the six organs reads its **real endpoint** and lights up with its honest
+live status; press **Run proactive cycle** to watch the GPU mind act
+(IMMUNE → BRAIN → run → HEART/BLOOD → NERVOUS), pulsing each organ in turn:
+
+| Organ | Proven formula (round9) | Live endpoint read |
+|---|---|---|
+| BRAIN | BrainBeliefUpdate (PAC-Bayes McAllester) | amaru `/api/amaru/v1/formulas` |
+| HEART | HeartReceiptSigma (σ-algebra receipt bus) | amaru `/api/amaru/receipts` |
+| BLOOD | BloodDSSEMerkle (Cardano-anchored DSSE) | sentra `/api/sentra/khipu/ledger` |
+| IMMUNE | ImmuneNeymanPearson (deny-by-default gates) | sentra `/api/sentra/v1/gates` |
+| SKELETON | SkeletonLambdaSpine (Lean kernel; Λ=Conj 1) | amaru `/api/amaru/v1/math/lean/theorems` |
+| NERVOUS | NervousShannonAlarm (Λ-signed OTEL drift) | amaru `/api/amaru/overwatch/snapshot` |
+
+The **GPU-mind posture** card reads a11oy `/api/a11oy/code/healthz`
+(`sovereign` / `backend` / `mode`); the honesty strip reads the doctrine lock
+live from a11oy `/api/a11oy/v1/honest`.
+
+**Honest by design (doctrine v11/v12):**
+- `sovereign:true` is shown **only** when `/code/healthz` reports the literal
+  `true` — never synthesized from a truthy value. If the mind is unreachable the
+  card shows `sovereign: false`. The half-state (banner sovereign while a router
+  serves) is the one outcome the view will never render.
+- Energy / joules are labeled **SAMPLE** until a real meter is wired.
+- **Λ is shown as Conjecture 1** (the skeleton's killer formula is intentionally
+  a conjecture), pulled live, never hardcoded as proven.
+- An unreachable endpoint degrades to an honest `unreachable — … · honest
+  empty-state`; no green light is ever fabricated for an organ that did not
+  answer. (Today amaru/sentra spaces may be unrouted → those organs honestly
+  read unreachable; a11oy + the mind posture read live.)
+- Read-only, sends no key, open-weight only.
+
+See `SCREENSHOT_NOTES.md` for the body layout and what a reviewer should see in a
+deploy preview.
+
+## Run, test, rollback (operability)
+
+This Space is a static bundle served by a thin Docker wrapper (`sdk: docker`; a
+`python http.server` on port 7860) — no application backend, and the bundle itself is
+static and offline-capable. To run and test locally:
+
+```bash
+# run: serve the bundle from the repo root with any static server
+python3 -m http.server 8000          # then open http://localhost:8000/index.html
+
+# test: the headless QA harness (Playwright/Chromium) renders all three
+# viewports, asserts 0 console errors, exercises the v4 dissection dock + the
+# v6 yarqa CFD layer, and confirms yarqa is NEVER counted in the locked-8.
+npm i -D playwright && npx playwright install chromium
+node qa_yarqa.js
+```
+
+**Health:** the page is "healthy" when `index.html` renders the 3D atlas with zero
+console errors at all three viewports (the QA assertion). The live-lens panels poll
+a11oy read-only and **degrade to a labeled `offline · static snapshot`** when an
+endpoint is unreachable — an offline endpoint is an expected state, not an outage.
+
+**Rollback (one step):** every deploy is a git commit; to revert the live Space to a
+known-good state, redeploy the previous tag/commit — `git revert <bad-sha>` (or reset
+the HF Space mirror to the prior commit). Because the bundle is fully static and
+self-contained (vendored `lib/three.min.js`, no runtime CDN), a rollback is just
+"serve the older files" — there is no migration or state to unwind.
+
+**Service ownership:** see `.github/CODEOWNERS`.
+
+## Security headers (SAFE-NOW hardening, R2)
+
+This Space serves a fully static bundle via a thin Docker wrapper (`sdk: docker`;
+a `python http.server` on port 7860). Under `sdk: docker` Hugging Face does **not**
+apply a README `custom_headers` block (that lever is static-SDK only), so the
+cross-origin headers are emitted by the container's own static server. Hardening is
+split across the two levers that actually take effect, and nothing is set that the
+browser would silently ignore (doctrine v11: never fabricate):
+
+- **Response headers emitted by the Space's static server** (set on every response):
+  - `cross-origin-opener-policy: same-origin-allow-popups`
+  - `cross-origin-resource-policy: cross-origin` (keeps the page loadable inside
+    the legitimate `huggingface.co` / `*.hf.space` embed iframe).
+  - COEP `require-corp` is **intentionally not set** — it would block the page's
+    read-only cross-origin fetches to a11oy/amaru/sentra and buys nothing here
+    (no `SharedArrayBuffer`/wasm).
+- **`<meta http-equiv>` in `index.html` + `live-body.html`** (what the browser
+  honors from markup):
+  - **Content-Security-Policy** (enforced, non-breaking): `default-src 'self'`;
+    `object-src 'none'`; `base-uri 'self'`; an explicit `connect-src` allow-list
+    (self + the four SZL `*.hf.space` origins it reads); `img-src 'self' data:
+    blob:`. `script-src`/`style-src` keep `'unsafe-inline'` **on purpose** — the
+    3D atlas ships heavy inline JS, inline styles, and a WebGL canvas, so a strict
+    nonce/hash CSP would white-screen it. The win is origin-locking: no rogue
+    external script, CDN, or pixel can load.
+  - **X-Content-Type-Options: nosniff** and **Referrer-Policy:
+    strict-origin-when-cross-origin**.
+
+**Why no HSTS / `frame-ancestors` / Report-Only here:** browsers ignore HSTS,
+CSP `frame-ancestors`, and `Content-Security-Policy-Report-Only` when delivered
+via `<meta>`, and the static server does not emit them as real headers — so setting
+them in-repo would be security theater. HF already terminates TLS and redirects to
+HTTPS at the edge. **Embedding is deliberately left enabled** (no
+`X-Frame-Options: DENY`, no `disable_embedding`) so the Space keeps working inside
+the `huggingface.co` / `*.hf.space` iframe.
+
+**CORS:** the evidence endpoints are public, read-only inspection contracts and
+return `Access-Control-Allow-Origin: *` so A11OY and the wider estate can ingest
+them. The only POST is a pure receipt recomputation; it cannot sign, store, fetch
+user-controlled URLs, or mutate state. Outbound dependency probes use a fixed
+allowlist in `server.py`; no key, cookie, or credential is sent.
+
+## Verify it yourself
+
+The organism is a map, not the source of truth — every claim it draws is checkable against the
+live products it depicts:
+
+```bash
+# Confirm the live doctrine posture the heart reports
+curl -s https://szlholdings-a11oy.hf.space/api/a11oy/v1/honest | jq .kernel_commit   # => "c7c0ba17"
+# Inspect and replay the Anatomy bundle receipt (result is STRUCTURAL-ONLY, not signed)
+curl -s https://betterwithage-anatomy.hf.space/api/anatomy/v1/receipt -o anatomy-receipt.json
+curl -s -X POST -H "Content-Type: application/json" --data-binary @anatomy-receipt.json \
+  https://betterwithage-anatomy.hf.space/api/anatomy/v1/verify/receipt | jq .verdict
+# Open the independent browser verifier for signed governed receipts
+open https://huggingface.co/spaces/SZLHOLDINGS/governed-receipt-verifier
+```
+
+Read the thesis → [szl-papers](https://github.com/szl-holdings/szl-papers) ·
+run the kernel → [lutar-lean](https://github.com/szl-holdings/lutar-lean).
+
+---
+
+Declared source base: `szl-holdings/anatomy` (GitHub) → `betterwithage/anatomy` (HF Space). The live source attestation reports the exact deployment revision and whether the HF overlay still needs GitHub synchronization. · **[a-11-oy.com](https://a-11-oy.com)**
+
+<sub>v5 (evolves v4) — WILLAY conscience · sovereign mesh · buyer-verifiable receipts · 8-proof→organ map · AI-assurance · yarqa+PINN (MODELED) · GPU-sovereign stack (SUBSTRATE) · Doctrine v11 LOCKED · 749/14/163 · kernel `c7c0ba17` · 8 locked-proven + experimental CI-green tier · Λ = Conjecture 1 · Khipu Conjecture 2 open · SLSA L1 honest (static viz) · Apache-2.0</sub>
+
+---
+
+## ◇ Part of the SZL Holdings estate — *governed AI you can prove*
+
+One sovereign substrate, many organs — every decision carries a signed, checkable receipt.
+
+**[◇ Holographic Estate — the showcase](https://szlholdings-holographic.hf.space)** ·
+[🛡️ a11oy](https://huggingface.co/spaces/SZLHOLDINGS/a11oy) ·
+[🧬 IMMUNE](https://huggingface.co/spaces/SZLHOLDINGS/immune) ·
+[🦅 killinchu](https://huggingface.co/spaces/SZLHOLDINGS/killinchu) ·
+[🫀 anatomy](https://huggingface.co/spaces/betterwithage/anatomy) ·
+[🌌 cosmos](https://huggingface.co/spaces/SZLHOLDINGS/cosmos) ·
+[🛰️ SDA](https://huggingface.co/spaces/SZLHOLDINGS/sda) ·
+[🌊 yarqa](https://huggingface.co/spaces/SZLHOLDINGS/yarqa) ·
+[🤗 all Spaces](https://huggingface.co/SZLHOLDINGS)
+
+**Governed-receipt cluster** — the open receipt format, an offline verifier, and a conformance bench (the DSSE Khipu receipts this organism depicts conform to this spec):
+[📐 governed-receipt-spec](https://github.com/szl-holdings/governed-receipt-spec) ·
+[✅ receipt verifier](https://huggingface.co/spaces/SZLHOLDINGS/governed-receipt-verifier) ·
+[📦 receipts bench](https://huggingface.co/datasets/SZLHOLDINGS/governed-receipts-bench)
+
+<sub>Doctrine v11 · Λ = Conjecture 1 (advisory — never "green"/theorem; open) · honest by design · public data only.</sub>

SCREENSHOT_NOTES.md

@@ -0,0 +1,102 @@
+# SCREENSHOT_NOTES — live body view (`live-body.html`)
+
+No headless browser is available in this lane, so the page was verified by
+**static parse + a Node functional test of the engine logic** (see "How it was
+verified" below) rather than a rendered screenshot. These notes describe the
+exact layout a reviewer should see in an HF **deploy preview** of the
+`feat/anatomy-live-body-view` branch, so the visual result can be checked
+against intent.
+
+## Body layout (top → bottom)
+
+```
+┌───────────────────────────────────────────────────────────────────────────┐
+│  SZL LIVING ANATOMY · LIVE BODY VIEW                  ┌─ GPU mind · posture ┐│
+│  The agentic GPU MIND, inside its proven body         │ sovereign  [false]  ││
+│  <one-paragraph intro + "← full 3D atlas" link>       │ backend    hf-router││
+│                                                       │ mode       live     ││
+│                                                       │ doctrine   v12       ││
+│                                                       └─────────────────────┘│
+│                                                                             │
+│  [ ▶ Run proactive cycle ]  [ ↻ Refresh organ status ]  [ ⚡ energy: SAMPLE ]│
+│                                                                             │
+│  ┌── IMMUNE ⛨ ─ step 0 ──┐  ┌── BRAIN ✸ ─ step 1 ───┐  ┌── HEART ❤ step 3 ─┐│
+│  │ Neyman-Pearson gates  │  │ PAC-Bayes McAllester  │  │ σ-algebra receipts ││
+│  │ ● <status detail>     │  │ ● <status detail>     │  │ ● <status detail>  ││
+│  │ <endpoint url>        │  │ <endpoint url>        │  │ <endpoint url>     ││
+│  └───────────────────────┘  └───────────────────────┘  └────────────────────┘│
+│  ┌── BLOOD 🜂 ─ step 4 ──┐  ┌── SKELETON ⊟ spine ──┐  ┌── NERVOUS ⌁ step 5 ┐│
+│  │ DSSE Merkle provenance│  │ Lean kernel · Λ=Conj1 │  │ Shannon drift alarm ││
+│  │ ● <status detail>     │  │ ● <status detail>     │  │ ● <status detail>  ││
+│  └───────────────────────┘  └───────────────────────┘  └────────────────────┘│
+│                                                                             │
+│  <cycle log line — narrates immune→brain→heart→blood→nervous>               │
+│  ┌─ honest by design ───────────────────────────────────────────────────┐  │
+│  │ ● Λ = Conjecture 1   ● sovereign only from /code/healthz   ● SAMPLE … │  │
+│  └──────────────────────────────────────────────────────────────────────┘  │
+└───────────────────────────────────────────────────────────────────────────┘
+```
+
+- **Six organ cards** in a responsive `auto-fit` grid (3-up on desktop, 1-up on
+  mobile). Each card carries its colored accent bar, glyph, proven-formula line,
+  agentic role, a **status dot + detail line**, and the real endpoint URL.
+- The **GPU-mind posture** card sits top-right with the live `sovereign` badge.
+- Organ colors reuse the existing `index.html` tokens: HEART `#ff5d8f`, BLOOD
+  `#ff3b5c`, BRAIN `#7c5cff`, NERVOUS `#5ad1ff`, SKELETON/IMMUNE `#ffd166`.
+
+## Status-dot states (honest)
+
+- **live** (cyan dot, card border brightens): endpoint answered `2xx` with usable
+  JSON; the detail line shows a short summary (e.g. "8 deny-by-default gates
+  armed", "pac_bayes_mcallester present").
+- **pending** (amber, breathing): mid-probe.
+- **unreachable** (grey dot, dimmed text): network/CORS/timeout/non-JSON →
+  reads `unreachable — <why> · honest empty-state`. **No green light is ever
+  shown for an organ that did not answer.**
+
+## What the proactive-cycle button does
+
+Pressing **▶ Run proactive cycle** pulses the organs in the canonical order
+**IMMUNE → BRAIN → HEART → BLOOD → NERVOUS** (SKELETON is the always-on spine and
+is excluded from the cycle). Each pulse is a ~1s color flash + lift; the cycle
+log narrates each phase and ends with *"reactive turns were never gated (they
+always preempt)."* Respects `prefers-reduced-motion` (border highlight instead of
+motion).
+
+## Expected live state TODAY (honest)
+
+At the time this was built:
+- **GPU mind** (`/api/a11oy/code/healthz`): reachable → `sovereign: false`
+  (router-served, `backend: hf-router`, `mode: live`, `doctrine: v12`). This is
+  the **correct, honest** reading — it is NOT sovereign while a router serves,
+  and the view says so plainly.
+- **Honesty strip** (`/api/a11oy/v1/honest`): reachable → Λ = Conjecture 1,
+  8 locked-proven, 749/14/163 @ `c7c0ba17`.
+- **amaru / sentra organ endpoints**: their HF spaces currently return non-JSON
+  (unrouted) → BRAIN/HEART/BLOOD/IMMUNE/SKELETON/NERVOUS honestly read
+  **unreachable · honest empty-state**. When those spaces are routed the same
+  page lights them green with no code change.
+
+So a reviewer opening the deploy preview should expect: **mind posture + honesty
+strip live; organ cards in honest unreachable states until amaru/sentra route.**
+That is the doctrine floor working as intended, not a bug.
+
+## How it was verified (no headless browser)
+
+- `node --check live-body.js` → PASS.
+- Inline `<script type="module">` extracted from `live-body.html` →
+  `node --check` PASS.
+- HTML tag-balance lint (html/head/body/style/script/main/header/section/footer)
+  → all balanced; DOCTYPE present.
+- **Engine functional test** (mocked `fetch`, 14 assertions, all pass):
+  - proactive cycle order is exactly `immune→brain→heart→blood→nervous`;
+    skeleton excluded.
+  - `summarize` tolerates real + empty/odd JSON shapes without throwing.
+  - `probeOrgan` degrades to `unreachable` on network error and on non-JSON
+    (HF 404 HTML), and reads `live` on real JSON.
+  - `probeMind` sets `sovereign:true` **only** on the literal `true`, never on a
+    truthy string, and reports `sovereign:false` when the mind is unreachable
+    (the half-state is unrepresentable).
+
+A rendered screenshot still requires an HF **deploy preview** of the branch —
+flagged here for the reviewer.

SECURITY.md

@@ -0,0 +1,62 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x     | :white_check_mark: |
+| < 1.0   | :x:                |
+
+## Reporting a Vulnerability
+
+**Do NOT open a public GitHub issue for security vulnerabilities.**
+
+Please report security vulnerabilities via email to **security@szlholdings.ai** with:
+
+1. Description of the vulnerability
+2. Steps to reproduce
+3. Potential impact assessment
+4. Any suggested mitigations
+
+### Response SLA
+
+| Severity | Initial Response | Resolution Target |
+|---|---|---|
+| Critical | 24 hours | 7 days |
+| High | 48 hours | 30 days |
+| Medium | 5 business days | 90 days |
+| Low | 10 business days | 180 days |
+
+We follow a **90-day responsible disclosure** policy. After 90 days from initial report, details may be published regardless of patch status (with appropriate notice to reporter).
+
+## Supply-Chain Security
+
+- **SLSA Build Level 1** — build provenance generated per release (honest; not L2/L3)
+- **Cosign keyless signing** — containers signed via Sigstore OIDC keyless mode; verify with `cosign verify ghcr.io/szl-holdings/anatomy:<tag>`
+- **SBOM** — CycloneDX SBOM attached to each GitHub Release
+
+## Section 889 Attestation
+
+SZL Holdings attests that no covered telecommunications equipment or services from the following vendors are used in this software:
+
+1. Huawei Technologies Company
+2. ZTE Corporation
+3. Hytera Communications Corporation
+4. Hangzhou Hikvision Digital Technology Company
+5. Dahua Technology Company
+
+Per NDAA Section 889, 41 U.S.C. § 4713.
+
+## Doctrine
+
+- Doctrine v11 LOCKED — kernel commit `c7c0ba17` (749 declarations / 14 axioms / 163 sorries)
+- Λ = Conjecture 1 (never a theorem)
+- No Iron Bank, FedRAMP, CMMC, or SWFT claims
+
+## Contact
+
+- **Security disclosures:** security@szlholdings.ai
+- **General:** hello@szlholdings.ai
+- **Website:** https://szlholdings.ai
+
+*This policy follows [OpenSSF Vulnerability Disclosure Guide](https://github.com/ossf/oss-vulnerability-guide).*

__gitattributes__.txt

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

covenant-cockpit.html

@@ -0,0 +1,448 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<!-- SAFE-NOW hardening (R2): browser-honored CSP subset + nosniff + Referrer-Policy.
+     HSTS / frame-ancestors omitted (browsers ignore them in <meta>; setting them
+     would be fabrication). 'unsafe-inline' is required: this page ships an inline
+     module script + inline styles, and Three.js is a vendored same-origin script.
+     connect-src is 'self' only — the cockpit reads bundled same-origin receipt JSON
+     and verifies entirely in-browser; it sends no key and calls no external origin. -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'self'; form-action 'self'" />
+<meta http-equiv="X-Content-Type-Options" content="nosniff" />
+<meta name="referrer" content="strict-origin-when-cross-origin" />
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=2" />
+<title>SZL Living Anatomy — Covenant Cockpit v1 · the holographic trust surface</title>
+<meta name="description" content="Covenant Cockpit v1: a 3D provenance graph rendered from REAL szl-receipt in-toto receipts. Each decision node links to the Λ-gate that governed it, the Lean proof backing the kernel invariant, the energy it burned (measured joules or honest UNAVAILABLE), and the BFT witnesses that co-signed. Click a node for its receipt fields + a genuine WebCrypto verify badge. No receipts → an honest empty state, never fabricated nodes. Λ = Conjecture 1." />
+<style>
+  :root{
+    --void:#080c14; --void2:#0b1120;
+    --proof:#3af4c8; --lattice:#5b8dee; --gold:#d7b96b; --warn:#e0795b;
+    --audit:#9ef0c0; --dim:#3a4456; --text:#e9eef7; --muted:#8b97b4; --faint:#5d6a8f;
+    --surface:rgba(11,17,32,0.72); --surface2:rgba(16,24,44,0.92);
+    --border:rgba(91,141,238,0.18); --border-strong:rgba(91,141,238,0.36);
+    --radius:14px; --blur:18px;
+    --font-d:"Space Grotesk",ui-sans-serif,system-ui,-apple-system,"Segoe UI",Inter,Roboto,sans-serif;
+    --font-m:"JetBrains Mono",ui-monospace,"SF Mono",Menlo,Consolas,monospace;
+    --shadow:0 18px 60px rgba(0,0,0,0.6);
+  }
+  *{box-sizing:border-box;margin:0;padding:0}
+  html,body{height:100%;background:var(--void);color:var(--text);
+    font-family:var(--font-d);-webkit-font-smoothing:antialiased;overflow:hidden}
+  a{color:var(--proof);text-decoration:none} a:hover{text-decoration:underline}
+
+  #scene{position:fixed;inset:0;display:block;touch-action:none}
+
+  .hud{position:fixed;z-index:5;pointer-events:none}
+  .panel{pointer-events:auto;background:var(--surface);backdrop-filter:blur(var(--blur));
+    border:1px solid var(--border);border-radius:var(--radius);box-shadow:var(--shadow)}
+  .hdr{font-family:var(--font-m);font-size:9px;letter-spacing:.22em;text-transform:uppercase;
+    color:var(--faint);padding-bottom:8px;margin-bottom:9px;border-bottom:1px solid var(--border)}
+
+  /* top-left: title */
+  #title{top:16px;left:16px;max-width:min(48ch,calc(100vw - 32px))}
+  #title .inner{padding:13px 15px}
+  #title .eyebrow{font-family:var(--font-m);font-size:9px;letter-spacing:.26em;text-transform:uppercase;color:var(--faint);margin-bottom:6px}
+  #title h1{font-size:18px;font-weight:600;line-height:1.15;letter-spacing:-.01em}
+  #title h1 .accent{color:var(--proof)}
+  #title .sub{font-size:11px;color:var(--muted);margin-top:8px;line-height:1.45}
+
+  /* top-right: legend + stats */
+  #stats{top:16px;right:16px;width:min(260px,calc(100vw - 32px));padding:13px 15px}
+  #stats .row{display:flex;justify-content:space-between;gap:9px;font-size:11px;line-height:1.7;color:var(--muted)}
+  #stats .row b{color:var(--text);font-weight:600;font-family:var(--font-m);font-size:11px}
+  #stats .src{font-family:var(--font-m);font-size:9px;color:var(--faint);margin-top:8px;padding-top:8px;border-top:1px solid var(--border);line-height:1.5;word-break:break-all}
+
+  /* bottom-left: node inspector */
+  #inspect{bottom:16px;left:16px;width:min(340px,calc(100vw - 32px));padding:13px 15px;max-height:min(62vh,560px);overflow:auto}
+  #inspect .kind{display:inline-block;font-family:var(--font-m);font-size:9px;letter-spacing:.06em;text-transform:uppercase;
+    padding:2px 8px;border-radius:99px;border:1px solid currentColor}
+  #inspect h2{font-size:14px;font-weight:600;margin:9px 0 4px;line-height:1.2;word-break:break-word}
+  #inspect .frow{display:flex;gap:8px;font-size:10.5px;line-height:1.5;margin-bottom:4px}
+  #inspect .frow .k{flex:0 0 88px;color:var(--faint);font-family:var(--font-m);font-size:9px;letter-spacing:.03em;text-transform:uppercase}
+  #inspect .frow .v{color:var(--text);font-family:var(--font-m);font-size:10px;word-break:break-word;flex:1}
+  #inspect .mut{color:var(--muted)}
+  #inspect .hint{color:var(--faint);font-size:10.5px;line-height:1.5}
+  .vbadge{display:inline-block;font-family:var(--font-m);font-size:10px;letter-spacing:.03em;padding:3px 10px;border-radius:99px;border:1px solid currentColor;margin-top:2px}
+  .v-verified{color:var(--proof)} .v-unavailable{color:var(--faint)} .v-failed{color:var(--warn)} .v-pending{color:var(--muted)}
+
+  /* bottom-right: doctrine footer */
+  #doctrine{bottom:16px;right:16px;width:min(300px,calc(100vw - 32px));padding:12px 15px;font-size:10px;color:var(--faint);line-height:1.55}
+  #doctrine b{color:var(--muted);font-weight:600}
+  .sw{display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--proof);box-shadow:0 0 6px currentColor;color:var(--proof);margin-right:6px;vertical-align:middle}
+
+  /* center legend */
+  .legend{position:fixed;z-index:5;left:50%;bottom:14px;transform:translateX(-50%);pointer-events:none;
+    display:flex;gap:13px;flex-wrap:wrap;justify-content:center;max-width:calc(100vw - 32px);
+    font-family:var(--font-m);font-size:9px;letter-spacing:.04em;color:var(--faint);
+    background:rgba(8,12,20,.55);padding:6px 13px;border-radius:99px;border:1px solid var(--border)}
+  .legend span{display:flex;align-items:center;gap:5px}
+  .legend i{width:8px;height:8px;border-radius:50%;display:inline-block}
+
+  /* honest empty state overlay */
+  #empty{position:fixed;inset:0;z-index:8;display:none;align-items:center;justify-content:center;flex-direction:column;
+    background:var(--void);color:var(--muted);text-align:center;padding:24px}
+  #empty .glyph{font-size:42px;color:var(--dim);margin-bottom:14px}
+  #empty h2{font-size:17px;font-weight:600;color:var(--text);margin-bottom:8px}
+  #empty p{font-size:12px;color:var(--faint);line-height:1.6;max-width:44ch}
+  #empty code{font-family:var(--font-m);color:var(--muted)}
+
+  #boot{position:fixed;inset:0;z-index:9;display:flex;align-items:center;justify-content:center;
+    background:var(--void);color:var(--faint);font-family:var(--font-m);font-size:12px;letter-spacing:.08em}
+
+  @media (max-width:760px){
+    #title h1{font-size:15px}
+    #stats,#inspect,#doctrine{width:calc(100vw - 32px)}
+    #stats{display:none}                 /* keep title + inspector on phones */
+    .legend{font-size:8px;gap:8px;bottom:10px}
+  }
+</style>
+</head>
+<body>
+<canvas id="scene" aria-label="3D provenance graph of governed decisions and their proofs"></canvas>
+<div id="boot">loading receipts…</div>
+
+<div class="hud" id="title"><div class="inner">
+  <div class="eyebrow">SZL Living Anatomy · covenant cockpit v1</div>
+  <h1>The <span class="accent">provenance graph</span> of every governed decision</h1>
+  <div class="sub">Each node is a REAL receipt. Edges bind it to the Λ-gate that governed it,
+    the Lean proof backing the kernel, the energy it burned, and the BFT witnesses that co-signed.
+    Click a node for its fields + a genuine verify badge. <a href="./index.html">← full 3D atlas</a></div>
+</div></div>
+
+<div class="hud panel" id="stats" aria-live="polite">
+  <div class="hdr">provenance · honest counts</div>
+  <div class="row"><span>decisions</span><b id="s-dec">…</b></div>
+  <div class="row"><span>Λ-gates</span><b id="s-gate">…</b></div>
+  <div class="row"><span>Lean proofs</span><b id="s-proof">…</b></div>
+  <div class="row"><span>BFT witnesses</span><b id="s-wit">…</b></div>
+  <div class="row"><span>verified / unavail</span><b id="s-ver">…</b></div>
+  <div class="row"><span>energy meas / UNAVAIL</span><b id="s-energy">…</b></div>
+  <div class="src" id="s-src">source: …</div>
+</div>
+
+<div class="hud panel" id="inspect" aria-live="polite">
+  <div class="hdr">node inspector</div>
+  <div id="inspect-body"><div class="hint">Click any node to inspect its real receipt fields.
+    Nothing here is fabricated — an unsigned receipt reads UNAVAILABLE, never a fake pass.</div></div>
+</div>
+
+<div class="hud panel" id="doctrine">
+  <span class="sw"></span><b>Λ = Conjecture 1</b> — advisory, never a theorem.<br>
+  <span class="sw" style="color:var(--proof)"></span>The Lean node backs the <b>kernel invariant</b>, not “the AI is correct”.<br>
+  <span class="sw" style="color:var(--warn)"></span>Energy = verbatim joules or honest <b>UNAVAILABLE</b> — never fabricated.<br>
+  <span class="sw" style="color:var(--gold)"></span>Verify badge = real WebCrypto ECDSA-P256 · read-only · no key sent.
+</div>
+
+<div class="legend hud" id="legend"></div>
+
+<div id="empty">
+  <div class="glyph">◇</div>
+  <h2>No receipts yet</h2>
+  <p>The Covenant Cockpit renders only REAL receipts. Drop a <code>receipts.json</code>
+    (szl-receipt in-toto shape) next to this page, or restore the bundled
+    <code>receipts.sample.json</code>, and the provenance graph will appear.
+    Nothing is fabricated here. &nbsp;<a href="./index.html">← full 3D atlas</a></p>
+</div>
+
+<script src="./lib/three.min.js"></script>
+<script type="module">
+import CC from "./covenant-cockpit.js";
+const THREE = window.THREE;
+const K = CC.KANCHAY;
+const $ = (id) => document.getElementById(id);
+
+/* ============================ scene scaffold ============================== */
+const canvas = $("scene");
+const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: false });
+renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
+renderer.setClearColor(new THREE.Color(K.void), 1);
+
+const scene = new THREE.Scene();
+scene.fog = new THREE.FogExp2(new THREE.Color(K.void), 0.055);
+const camera = new THREE.PerspectiveCamera(46, 1, 0.1, 100);
+camera.position.set(0, 0.6, 7.2);
+
+scene.add(new THREE.AmbientLight(0x4a5878, 0.95));
+const key = new THREE.PointLight(0x9fc2ff, 1.1, 60); key.position.set(5, 7, 9); scene.add(key);
+const rim = new THREE.PointLight(0x3af4c8, 0.6, 60); rim.position.set(-7, -4, 5); scene.add(rim);
+
+const root = new THREE.Group(); scene.add(root);
+
+/* radial glow sprite (additive) */
+function glowTexture() {
+  const s = 64, c = document.createElement("canvas"); c.width = c.height = s;
+  const g = c.getContext("2d");
+  const grd = g.createRadialGradient(s/2, s/2, 0, s/2, s/2, s/2);
+  grd.addColorStop(0, "rgba(255,255,255,1)");
+  grd.addColorStop(0.28, "rgba(255,255,255,0.5)");
+  grd.addColorStop(1, "rgba(255,255,255,0)");
+  g.fillStyle = grd; g.fillRect(0, 0, s, s);
+  const t = new THREE.CanvasTexture(c); t.needsUpdate = true; return t;
+}
+const GLOW = glowTexture();
+function glowSprite(color, scale, opacity) {
+  const m = new THREE.SpriteMaterial({ map: GLOW, color: new THREE.Color(color),
+    transparent: true, opacity, blending: THREE.AdditiveBlending, depthWrite: false });
+  const sp = new THREE.Sprite(m); sp.scale.set(scale, scale, 1); return sp;
+}
+
+/* node geometry per kind */
+function nodeGeo(kind) {
+  switch (kind) {
+    case "decision": return new THREE.IcosahedronGeometry(0.22, 1);
+    case "gate":     return new THREE.DodecahedronGeometry(0.19, 0);
+    case "proof":    return new THREE.OctahedronGeometry(0.20, 0);
+    case "energy":   return new THREE.TetrahedronGeometry(0.18, 0);
+    case "witness":  return new THREE.BoxGeometry(0.26, 0.26, 0.26);
+    default:         return new THREE.SphereGeometry(0.18, 12, 12);
+  }
+}
+
+/* ============================ state ====================================== */
+let GRAPH = { nodes: [], edges: [], stats: {} };
+let RECEIPTS = [];
+let COSIGN_KEY = null;
+const nodeMeshes = new Map();     // node.id -> {node, core, halo, mat, baseEmissive}
+const verifyCache = new Map();    // receiptIndex -> {status, detail}
+let selectedId = null;
+
+/* ============================ build scene from graph ===================== */
+function edgeColor(kind) {
+  if (kind === "governs") return K.gold;
+  if (kind === "backs")   return K.proof;
+  if (kind === "burned")  return K.warn;
+  if (kind === "cosigned")return K.audit;
+  return K.lattice;
+}
+function buildScene() {
+  // nodes
+  for (const n of GRAPH.nodes) {
+    const meta = CC.NODE_KIND[n.kind] || { color: K.lattice };
+    let col = new THREE.Color(meta.color);
+    if (n.kind === "energy" && !n.meta.measured) col = new THREE.Color(K.dim);  // honest UNAVAILABLE
+    const mat = new THREE.MeshStandardMaterial({ color: col, emissive: col,
+      emissiveIntensity: 0.35, metalness: 0.25, roughness: 0.45, flatShading: true });
+    const core = new THREE.Mesh(nodeGeo(n.kind), mat);
+    core.position.set(n.pos[0], n.pos[1], n.pos[2]);
+    core.userData.nodeId = n.id;
+    const halo = glowSprite(col.getStyle(), 0.85, 0.18); halo.position.copy(core.position);
+    root.add(core); root.add(halo);
+    nodeMeshes.set(n.id, { node: n, core, halo, mat, baseEmissive: 0.35 });
+  }
+  // edges (thin lines colored by relation)
+  const posOf = (id) => { const m = nodeMeshes.get(id); return m ? m.core.position : null; };
+  for (const e of GRAPH.edges) {
+    const a = posOf(e.from), b = posOf(e.to);
+    if (!a || !b) continue;
+    const geo = new THREE.BufferGeometry().setFromPoints([a.clone(), b.clone()]);
+    const mat = new THREE.LineBasicMaterial({ color: new THREE.Color(edgeColor(e.kind)),
+      transparent: true, opacity: 0.28 });
+    root.add(new THREE.Line(geo, mat));
+  }
+}
+
+/* ============================ stats + legend ============================= */
+function renderStats(source) {
+  const s = GRAPH.stats;
+  $("s-dec").textContent = s.decisions ?? 0;
+  $("s-gate").textContent = s.gates ?? 0;
+  $("s-proof").textContent = s.proofs ?? 0;
+  $("s-wit").textContent = s.witnesses ?? 0;
+  const verified = [...verifyCache.values()].filter((v) => v.status === CC.VERIFY.VERIFIED).length;
+  const unavail = [...verifyCache.values()].filter((v) => v.status !== CC.VERIFY.VERIFIED).length;
+  $("s-ver").textContent = `${verified} / ${unavail}`;
+  $("s-energy").textContent = `${s.energyMeasured ?? 0} / ${s.energyUnavailable ?? 0}`;
+  $("s-src").textContent = "source: " + (source || "—");
+}
+function renderLegend() {
+  const items = [
+    ["decision", K.lattice], ["Λ-gate", K.gold], ["Lean proof", K.proof],
+    ["energy", K.warn], ["BFT witness", K.audit], ["UNAVAILABLE", K.dim],
+  ];
+  $("legend").innerHTML = items.map(([t, c]) =>
+    `<span><i style="background:${c}"></i>${t}</span>`).join("");
+}
+
+/* ============================ verify all receipts ======================== */
+async function verifyAll() {
+  if (COSIGN_KEY == null) return;   // no key → all stay UNAVAILABLE (honest)
+  await Promise.all(RECEIPTS.map(async (r, i) => {
+    const v = await CC.verifyEnvelope(r.envelope, COSIGN_KEY);
+    verifyCache.set(i, v);
+  }));
+}
+
+/* ============================ node inspector ============================= */
+function badgeClass(status) {
+  return status === CC.VERIFY.VERIFIED ? "v-verified"
+    : status === CC.VERIFY.FAILED ? "v-failed"
+    : status === CC.VERIFY.PENDING ? "v-pending" : "v-unavailable";
+}
+function frow(k, v, mut) {
+  return `<div class="frow"><span class="k">${k}</span><span class="v ${mut ? "mut" : ""}">${v}</span></div>`;
+}
+function esc(x) { return String(x == null ? "" : x)
+  .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
+
+function inspect(node) {
+  const meta = CC.NODE_KIND[node.kind] || {};
+  const col = (node.kind === "energy" && !node.meta.measured) ? K.dim : (meta.color || K.lattice);
+  let html = `<span class="kind" style="color:${col}">${meta.glyph || ""} ${meta.label || node.kind}</span>`;
+  html += `<h2>${esc(node.label)}</h2>`;
+
+  if (node.kind === "decision") {
+    const r = RECEIPTS[node.meta.receiptIndex];
+    const b = r ? r.body : {};
+    const en = b.energy && typeof b.energy === "object" && typeof b.energy.joules === "number"
+      ? `${b.energy.joules} J (measured)` : "UNAVAILABLE";
+    html += frow("producer", esc(b.producer));
+    html += frow("model", esc(b.model_id));
+    html += frow("action", esc(b.action));
+    html += frow("verdict", esc(b.verdict));
+    if (b.reason) html += frow("reason", esc(b.reason), true);
+    html += frow("input", esc(b.input_digest), true);
+    html += frow("output", esc(b.output_digest), true);
+    html += frow("Λ-gate", esc(b.policy_id));
+    if (b.lambda) html += frow("Λ", `${esc(b.lambda.value)} ${b.lambda.pass ? "≥" : "<"} ${esc(b.lambda.floor)} · ${esc(b.lambda.uniqueness || "Conjecture 1")}`);
+    html += frow("Lean", `${esc(b.lean_theorem)} @ ${esc(b.kernel_commit)}`);
+    html += frow("energy", esc(en), en === "UNAVAILABLE");
+    html += frow("witnesses", esc((b.bft_witnesses || []).join(", ")));
+    html += frow("digest", esc((r && r.digest ? r.digest : "").slice(0, 32) + "…"), true);
+    const v = verifyCache.get(node.meta.receiptIndex) || { status: CC.VERIFY.PENDING, detail: "not yet run" };
+    html += `<div class="frow"><span class="k">verify</span><span class="v"><span class="vbadge ${badgeClass(v.status)}">${v.status === CC.VERIFY.VERIFIED ? "✓ verified" : v.status === CC.VERIFY.FAILED ? "✗ failed" : v.status === CC.VERIFY.PENDING ? "… pending" : "— UNAVAILABLE"}</span></span></div>`;
+    html += `<div class="hint" style="margin-top:6px">${esc(v.detail)}</div>`;
+  } else if (node.kind === "gate") {
+    const govern = RECEIPTS.filter((r) => r.body.policy_id === node.meta.policy_id).map((r) => r.id);
+    html += frow("policy id", esc(node.meta.policy_id));
+    html += frow("governs", esc(govern.join(", ")));
+    html += `<div class="hint" style="margin-top:6px">The deny-by-default gate that scored & governed these decisions. Λ is advisory (Conjecture 1), never a theorem.</div>`;
+  } else if (node.kind === "proof") {
+    const backs = RECEIPTS.filter((r) => r.body.lean_theorem === node.meta.lean_theorem).map((r) => r.id);
+    html += frow("lean theorem", esc(node.meta.lean_theorem));
+    html += frow("kernel", esc(node.meta.kernel_commit || "—"));
+    html += frow("backs", esc(backs.join(", ")));
+    html += `<div class="hint" style="margin-top:6px">Kernel-verified invariant backing these receipts — it proves the KERNEL property, not that the model's output is correct.</div>`;
+  } else if (node.kind === "energy") {
+    const r = RECEIPTS.find((x) => x.id === node.meta.receiptId);
+    html += frow("receipt", esc(node.meta.receiptId));
+    html += frow("joules", node.meta.measured ? esc(node.meta.joules + " J") : "UNAVAILABLE", !node.meta.measured);
+    html += `<div class="hint" style="margin-top:6px">${node.meta.measured ? "Verbatim measured energy from the receipt." : "No meter reported energy for this decision — honest UNAVAILABLE, never a fabricated joule."}</div>`;
+  } else if (node.kind === "witness") {
+    const cosigned = RECEIPTS.filter((r) => (r.body.bft_witnesses || []).includes(node.meta.witness)).map((r) => r.id);
+    html += frow("witness", esc(node.meta.witness));
+    html += frow("co-signed", esc(cosigned.join(", ")));
+    html += `<div class="hint" style="margin-top:6px">A BFT witness listed by these receipts as a co-signer of the decision.</div>`;
+  }
+  $("inspect-body").innerHTML = html;
+}
+
+/* selection highlight */
+function select(id) {
+  if (selectedId && nodeMeshes.has(selectedId)) {
+    const prev = nodeMeshes.get(selectedId); prev.mat.emissiveIntensity = prev.baseEmissive;
+    prev.halo.material.opacity = 0.18;
+  }
+  selectedId = id;
+  const m = nodeMeshes.get(id);
+  if (m) { m.mat.emissiveIntensity = 0.95; m.halo.material.opacity = 0.5; inspect(m.node); }
+}
+
+/* ============================ raycast picking =========================== */
+const raycaster = new THREE.Raycaster();
+const ndc = new THREE.Vector2();
+let downX = 0, downY = 0;
+function pick(clientX, clientY) {
+  const rect = canvas.getBoundingClientRect();
+  ndc.x = ((clientX - rect.left) / rect.width) * 2 - 1;
+  ndc.y = -((clientY - rect.top) / rect.height) * 2 + 1;
+  raycaster.setFromCamera(ndc, camera);
+  const cores = [...nodeMeshes.values()].map((v) => v.core);
+  const hits = raycaster.intersectObjects(cores, false);
+  if (hits.length) select(hits[0].object.userData.nodeId);
+}
+
+/* ============================ animation loop ============================= */
+let last = performance.now(), dragX = 0, dragY = 0, autoSpin = 0.05;
+function animate(now) {
+  const dt = Math.min(0.05, (now - last) / 1000); last = now;
+  for (const [id, m] of nodeMeshes) {
+    m.core.rotation.y += dt * 0.35; m.core.rotation.x += dt * 0.15;
+    if (id === selectedId) {
+      const pulse = 0.5 + Math.sin(now * 0.006) * 0.25;
+      m.halo.material.opacity = 0.35 + pulse * 0.3;
+    }
+  }
+  root.rotation.y += dt * autoSpin + dragX;
+  root.rotation.x += dragY;
+  root.rotation.x = Math.max(-0.55, Math.min(0.55, root.rotation.x));
+  dragX *= 0.85; dragY *= 0.85;
+  renderer.render(scene, camera);
+  requestAnimationFrame(animate);
+}
+
+/* ============================ resize + input ============================= */
+function resize() {
+  const w = window.innerWidth, h = window.innerHeight;
+  renderer.setSize(w, h, false); camera.aspect = w / h; camera.updateProjectionMatrix();
+}
+window.addEventListener("resize", resize); resize();
+
+let dragging = false, moved = false, lx = 0, ly = 0;
+canvas.addEventListener("pointerdown", (e) => {
+  dragging = true; moved = false; lx = e.clientX; ly = e.clientY;
+  downX = e.clientX; downY = e.clientY; autoSpin = 0;
+});
+window.addEventListener("pointerup", (e) => {
+  dragging = false; autoSpin = 0.05;
+  if (!moved) pick(e.clientX, e.clientY);   // treat as a click (not a drag)
+});
+window.addEventListener("pointermove", (e) => {
+  if (!dragging) return;
+  if (Math.abs(e.clientX - downX) > 4 || Math.abs(e.clientY - downY) > 4) moved = true;
+  dragX = (e.clientX - lx) * 0.00020; dragY = (e.clientY - ly) * 0.00013;
+  lx = e.clientX; ly = e.clientY;
+});
+
+/* ============================ boot ====================================== */
+(async () => {
+  renderLegend();
+  const loaded = await CC.loadReceipts();
+  RECEIPTS = loaded.receipts;
+  if (loaded.empty || RECEIPTS.length === 0) {
+    // HONEST empty state — never fabricate nodes
+    $("boot").style.display = "none";
+    $("empty").style.display = "flex";
+    renderStats(loaded.source);
+    // still run a bare render loop so the (empty) canvas is valid
+    requestAnimationFrame(animate);
+    // expose for headless QA
+    window.__cockpit = { empty: true, source: loaded.source, nodes: [], edges: [], receipts: 0 };
+    return;
+  }
+  // import cosign pubkey (may be absent → verify stays UNAVAILABLE, honest)
+  if (loaded.cosignPub) {
+    try { COSIGN_KEY = await CC.importCosign(loaded.cosignPub); }
+    catch { COSIGN_KEY = null; }
+  }
+  GRAPH = CC.buildGraph(RECEIPTS);
+  buildScene();
+  await verifyAll();
+  renderStats(loaded.source);
+  $("boot").style.display = "none";
+  requestAnimationFrame(animate);
+
+  // expose an honest snapshot for the headless QA harness
+  window.__cockpit = {
+    empty: false, source: loaded.source,
+    nodes: GRAPH.nodes.length, edges: GRAPH.edges.length,
+    stats: GRAPH.stats, receipts: RECEIPTS.length,
+    verify: [...verifyCache.entries()].map(([i, v]) => ({ i, status: v.status })),
+    select: (id) => { select(id); return selectedId; },
+    firstDecisionId: (GRAPH.nodes.find((n) => n.kind === "decision") || {}).id || null,
+    inspectHTML: () => $("inspect-body").innerHTML,
+  };
+})();
+</script>
+</body>
+</html>

covenant-cockpit.js

@@ -0,0 +1,317 @@
+/* =============================================================================
+ * covenant-cockpit.js — SZL Living Anatomy · COVENANT COCKPIT v1 (data spine)
+ * =============================================================================
+ * The holographic trust surface of PCGI (Proof-Carrying Governed Intelligence).
+ * This module is the HONEST DATA SPINE for covenant-cockpit.html's Three.js
+ * scene. It reads REAL szl-receipt in-toto receipts and turns each governed
+ * decision into a provenance graph:
+ *
+ *     decision ──governs──▶  Λ-gate (policy_id)
+ *              ──backs────▶  Lean proof (lean_theorem @ kernel_commit)
+ *              ──burned───▶  energy (measured joules OR honest UNAVAILABLE)
+ *              ──cosigned─▶  BFT witness(es)
+ *
+ * CRITICAL DISCIPLINE (binding — honest by construction):
+ *   - Nodes come ONLY from real receipt JSON. No receipts → an HONEST empty
+ *     state ("no receipts yet"). We NEVER fabricate a node.
+ *   - The verify badge is a GENUINE WebCrypto ECDSA-P256-SHA256 check over the
+ *     szl-receipt DSSE PAE, against the bundled cosign public key. An unsigned
+ *     receipt reads UNAVAILABLE (unsigned-honest), never a fake "verified".
+ *   - Energy is verbatim measured joules OR the string UNAVAILABLE — a joule is
+ *     never fabricated.
+ *   - Λ is advisory; its uniqueness is Conjecture 1 — surfaced from the receipt,
+ *     never dressed up as a theorem. The Lean proof node backs the KERNEL
+ *     invariant, not "the AI is correct".
+ *   - Read-only, same-origin. Loads ./receipts.json if present, else the bundled
+ *     ./receipts.sample.json, else the honest empty state.
+ *
+ * No build step, no framework, no CDN — a plain ES module that runs as a static
+ * SDK page at the .static.hf.space URL, exactly like index.html / live-body.html.
+ * The pure functions (normalizeBundle / buildGraph / verifyEnvelope) take no DOM
+ * and are unit-tested headless in qa_cockpit.mjs.
+ * ============================================================================ */
+"use strict";
+
+/* ---- KANCHAY palette (canonical brand · purple BANNED) -------------------- */
+const KANCHAY = {
+  void:    "#080c14",
+  proof:   "#3af4c8",   // teal  — Lean proof / verified
+  lattice: "#5b8dee",   // blue  — decision node / edges
+  gold:    "#d7b96b",   // gold  — Λ-gate / policy
+  warn:    "#e0795b",   // ember — energy burned / failed verify
+  audit:   "#9ef0c0",   // mint  — BFT witness
+  dim:     "#3a4456",   // honest unavailable / dormant
+  text:    "#e9eef7",
+};
+
+/* ---- node kinds → color + geometry hint ---------------------------------- */
+const NODE_KIND = {
+  decision: { color: KANCHAY.lattice, glyph: "◆", label: "decision" },
+  gate:     { color: KANCHAY.gold,    glyph: "⛨", label: "Λ-gate" },
+  proof:    { color: KANCHAY.proof,   glyph: "⊢", label: "Lean proof" },
+  energy:   { color: KANCHAY.warn,    glyph: "⚡", label: "energy" },
+  witness:  { color: KANCHAY.audit,   glyph: "✍", label: "BFT witness" },
+};
+
+/* ---- verify status vocabulary -------------------------------------------- */
+const VERIFY = {
+  VERIFIED:    "verified",     // signed + WebCrypto DSSE signature valid
+  UNAVAILABLE: "unavailable",  // unsigned-honest, or no pubkey, or not run
+  FAILED:      "failed",       // signed but signature invalid (tamper)
+  PENDING:     "pending",
+};
+
+/* ---- candidate data sources (same-origin, read-only) --------------------- */
+const SOURCES = ["./receipts.json", "./receipts.sample.json"];
+
+/* ---- one honest GET (never throws) --------------------------------------- */
+async function getJSON(url, timeoutMs = 9000) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "GET", mode: "same-origin", credentials: "omit",
+      signal: ctl.signal, cache: "no-store",
+    });
+    clearTimeout(t);
+    if (!res.ok) return { ok: false, why: `HTTP ${res.status}` };
+    return { ok: true, json: await res.json() };
+  } catch (e) {
+    clearTimeout(t);
+    return { ok: false, why: (e && e.name === "AbortError") ? "timeout" : "not found" };
+  }
+}
+
+/* ---- base64 → bytes (browser + node safe) -------------------------------- */
+function b64ToBytes(b64) {
+  if (typeof atob === "function") {
+    const bin = atob(String(b64).replace(/-/g, "+").replace(/_/g, "/"));
+    const u = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i);
+    return u;
+  }
+  return new Uint8Array(Buffer.from(String(b64), "base64"));   // node fallback
+}
+
+/* ---- normalize a loaded bundle into honest receipt records --------------- *
+ * Accepts the bundled shape {cosign_pub, receipts:[{id,envelope,statement}]}
+ * OR a bare array of envelopes/records. Returns decoded, doctrine-clean records.
+ * Pure: no DOM, no network. */
+function normalizeBundle(raw) {
+  let list = [];
+  let cosignPub = null;
+  if (Array.isArray(raw)) {
+    list = raw;
+  } else if (raw && typeof raw === "object") {
+    cosignPub = raw.cosign_pub || raw.cosignPub || null;
+    list = raw.receipts || raw.items || [];
+  }
+  const receipts = [];
+  for (const entry of (Array.isArray(list) ? list : [])) {
+    // an entry may be {envelope, statement, id} OR a bare envelope
+    const env = entry && entry.envelope ? entry.envelope
+      : (entry && entry.payload ? entry : null);
+    if (!env || !env.payload) continue;   // not a receipt shape → skip (no fake node)
+    let body = null;
+    try { body = JSON.parse(new TextDecoder().decode(b64ToBytes(env.payload))); }
+    catch { body = null; }
+    if (!body || typeof body !== "object") continue;   // undecodable → honest skip
+    receipts.push({
+      id: entry.id || body.subject || env.digest || `receipt-${receipts.length}`,
+      envelope: env,
+      statement: entry.statement || null,
+      body,
+      digest: env.digest || null,
+      signed: env.signed === true,
+    });
+  }
+  return { receipts, cosignPub };
+}
+
+/* ---- build the provenance graph from real receipts (PURE) ---------------- *
+ * Returns {nodes, edges, stats}. Empty input → empty graph (honest). */
+function buildGraph(receipts) {
+  const nodes = [];
+  const edges = [];
+  const byId = new Map();
+  const list = Array.isArray(receipts) ? receipts : [];
+
+  function ensure(id, kind, label, meta) {
+    let n = byId.get(id);
+    if (n) { n.degree++; return n; }
+    n = { id, kind, label, meta: meta || {}, degree: 1, pos: [0, 0, 0] };
+    byId.set(id, n); nodes.push(n);
+    return n;
+  }
+
+  list.forEach((r, i) => {
+    const b = r.body || {};
+    const dId = `d:${r.id}`;
+    const decision = ensure(dId, "decision", r.id, {
+      receiptIndex: i, receiptId: r.id, verdict: b.verdict, producer: b.producer,
+    });
+    // Λ-gate that governed it
+    if (b.policy_id) {
+      const g = ensure(`g:${b.policy_id}`, "gate", b.policy_id, { policy_id: b.policy_id });
+      edges.push({ from: dId, to: g.id, kind: "governs" });
+    }
+    // Lean proof backing the KERNEL invariant (not "the AI is correct")
+    if (b.lean_theorem) {
+      const p = ensure(`p:${b.lean_theorem}`, "proof", b.lean_theorem, {
+        lean_theorem: b.lean_theorem, kernel_commit: b.kernel_commit || null,
+      });
+      edges.push({ from: dId, to: p.id, kind: "backs" });
+    }
+    // energy burned (measured joules OR honest UNAVAILABLE)
+    const energy = b.energy;
+    const measured = energy && typeof energy === "object" && typeof energy.joules === "number";
+    const e = ensure(`e:${r.id}`, "energy", measured ? `${energy.joules} J` : "UNAVAILABLE", {
+      measured: !!measured,
+      joules: measured ? energy.joules : null,
+      receiptId: r.id,
+    });
+    edges.push({ from: dId, to: e.id, kind: "burned" });
+    // BFT witnesses that co-signed
+    for (const w of (Array.isArray(b.bft_witnesses) ? b.bft_witnesses : [])) {
+      const wn = ensure(`w:${w}`, "witness", String(w), { witness: String(w) });
+      edges.push({ from: dId, to: wn.id, kind: "cosigned" });
+    }
+  });
+
+  layout(nodes);
+
+  const stats = {
+    receipts: list.length,
+    decisions: nodes.filter((n) => n.kind === "decision").length,
+    gates: nodes.filter((n) => n.kind === "gate").length,
+    proofs: nodes.filter((n) => n.kind === "proof").length,
+    witnesses: nodes.filter((n) => n.kind === "witness").length,
+    energyMeasured: nodes.filter((n) => n.kind === "energy" && n.meta.measured).length,
+    energyUnavailable: nodes.filter((n) => n.kind === "energy" && !n.meta.measured).length,
+    edges: edges.length,
+  };
+  return { nodes, edges, stats };
+}
+
+/* deterministic 3D orbital layout by node kind (mutates node.pos) ----------- */
+function layout(nodes) {
+  const byKind = {};
+  for (const n of nodes) (byKind[n.kind] = byKind[n.kind] || []).push(n);
+  // ring placer: even angular spread, per-kind phase, on a shell
+  const ring = (arr, radius, y, phase, zJitter) => {
+    const n = arr.length;
+    arr.forEach((node, i) => {
+      const a = (n <= 1 ? phase : (i / n) * Math.PI * 2 + phase);
+      node.pos = [
+        Math.cos(a) * radius,
+        y + (zJitter ? Math.sin(i * 1.7) * zJitter : 0),
+        Math.sin(a) * radius,
+      ];
+      node._angle = a;
+    });
+  };
+  ring(byKind.decision || [], 1.5, 0.0, Math.PI / 2, 0.12);   // inner ring
+  ring(byKind.gate || [], 1.1, 1.5, 0.0, 0.0);                // top dome
+  ring(byKind.proof || [], 1.1, -1.5, Math.PI, 0.0);          // bottom dome
+  ring(byKind.witness || [], 3.1, 0.0, Math.PI / 5, 0.5);     // outer equatorial
+  // energy sits radially just outside its own decision
+  const decs = byKind.decision || [];
+  const decAngle = new Map(decs.map((d) => [d.meta.receiptId, d._angle]));
+  for (const e of (byKind.energy || [])) {
+    const a = decAngle.has(e.meta.receiptId) ? decAngle.get(e.meta.receiptId)
+      : Math.random() * Math.PI * 2;
+    e.pos = [Math.cos(a) * 2.3, -0.1, Math.sin(a) * 2.3];
+  }
+}
+
+/* ---- WebCrypto DSSE ECDSA-P256-SHA256 verify (szl-receipt binary-LE PAE) -- *
+ * Matches szl_receipt._canonical.pae EXACTLY: little-endian 64-bit lengths,
+ * NOT the ascii-decimal DSSE variant. Returns a VERIFY.* status. */
+function _cat() {
+  const arrs = [].slice.call(arguments);
+  let n = 0; for (const a of arrs) n += a.length;
+  const o = new Uint8Array(n); let p = 0;
+  for (const a of arrs) { o.set(a, p); p += a.length; }
+  return o;
+}
+function _le64(n) {
+  const b = new Uint8Array(8); let v = BigInt(n);
+  for (let i = 0; i < 8; i++) { b[i] = Number(v & 0xffn); v >>= 8n; }
+  return b;
+}
+function _paeBinary(payloadType, payloadBytes) {
+  const enc = new TextEncoder();
+  const t = enc.encode(payloadType || "");
+  return _cat(enc.encode("DSSEv1 "), _le64(t.length), t,
+    enc.encode(" "), _le64(payloadBytes.length), payloadBytes);
+}
+function _derToRaw(der) {
+  let i = 0;
+  if (der[i++] !== 0x30) throw new Error("bad DER (no SEQUENCE)");
+  let sl = der[i++]; if (sl & 0x80) { let n = sl & 0x7f; while (n--) i++; }
+  const rdInt = () => {
+    if (der[i++] !== 0x02) throw new Error("bad DER (no INTEGER)");
+    const len = der[i++]; let v = der.slice(i, i + len); i += len;
+    while (v.length > 1 && v[0] === 0) v = v.slice(1);
+    return v;
+  };
+  const r = rdInt(), s = rdInt();
+  const out = new Uint8Array(64); out.set(r, 32 - r.length); out.set(s, 64 - s.length);
+  return out;
+}
+function _subtle() {
+  if (typeof crypto !== "undefined" && crypto.subtle) return crypto.subtle;
+  if (typeof globalThis !== "undefined" && globalThis.crypto && globalThis.crypto.subtle)
+    return globalThis.crypto.subtle;
+  return null;
+}
+async function importCosign(pem) {
+  const s = _subtle(); if (!s) throw new Error("WebCrypto unavailable");
+  const b64 = String(pem).replace(/-----[^-]+-----/g, "").replace(/\s+/g, "");
+  return s.importKey("spki", b64ToBytes(b64), { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+}
+async function verifyEnvelope(envelope, key) {
+  if (!envelope || envelope.signed !== true || !envelope.signature)
+    return { status: VERIFY.UNAVAILABLE, detail: "unsigned-honest (no signature)" };
+  if (!key) return { status: VERIFY.UNAVAILABLE, detail: "no cosign public key bundled" };
+  const s = _subtle(); if (!s) return { status: VERIFY.UNAVAILABLE, detail: "WebCrypto unavailable" };
+  try {
+    const payload = b64ToBytes(envelope.payload);
+    const pae = _paeBinary(envelope.payloadType, payload);
+    const rawSig = _derToRaw(b64ToBytes(envelope.signature));
+    const ok = await s.verify({ name: "ECDSA", hash: "SHA-256" }, key, rawSig, pae);
+    return ok
+      ? { status: VERIFY.VERIFIED, detail: "ECDSA-P256-SHA256 over DSSE PAE — unaltered from signer" }
+      : { status: VERIFY.FAILED, detail: "signature mismatch — do NOT trust this receipt" };
+  } catch (e) {
+    return { status: VERIFY.UNAVAILABLE, detail: `verify error: ${e && e.message ? e.message : e}` };
+  }
+}
+
+/* ---- top-level loader (browser): first present source wins ---------------- */
+async function loadReceipts() {
+  for (const url of SOURCES) {
+    const r = await getJSON(url);
+    if (!r.ok) continue;
+    const { receipts, cosignPub } = normalizeBundle(r.json);
+    if (receipts.length === 0) continue;         // present but empty → try next
+    return { source: url, receipts, cosignPub, empty: false };
+  }
+  return { source: null, receipts: [], cosignPub: null, empty: true,
+    why: "no receipts.json or receipts.sample.json with valid receipts" };
+}
+
+/* ---- the engine surface -------------------------------------------------- */
+const CovenantCockpit = {
+  KANCHAY, NODE_KIND, VERIFY, SOURCES,
+  getJSON, b64ToBytes, normalizeBundle, buildGraph, layout,
+  importCosign, verifyEnvelope, loadReceipts,
+};
+
+if (typeof window !== "undefined") window.CovenantCockpit = CovenantCockpit;
+export default CovenantCockpit;
+export {
+  KANCHAY, NODE_KIND, VERIFY, SOURCES,
+  getJSON, b64ToBytes, normalizeBundle, buildGraph, layout,
+  importCosign, verifyEnvelope, loadReceipts,
+};

data.js

@@ -0,0 +1,1008 @@
+/* =====================================================================
+   SZL AGENT BODY v3 — ANATOMY DOCTRINE DATA MODEL
+   Single source of truth for the 3D anatomy. Transcribed from:
+     team/ANATOMY_DOCTRINE.md  (founder's v3 8-image roadmap)
+     team/_PROVEN_FORMULAS.md  (lutar-lean PROVEN_FORMULAS.md, kernel c7c0ba17)
+     team/PROVE_NEXT10_REPORT.md (Wave8, main @ 7885fd9)
+   Honesty doctrine v11 LOCKED. No fabricated metrics, no AGI, no vendor
+   model-codenames. Quechua organ names KEPT as architectural identity,
+   always paired with plain-English FUNCTION.
+   ===================================================================== */
+(function (root) {
+  'use strict';
+
+  /* ---- Kernel posture (honest, from lutar-lean main) ---- */
+  const KERNEL = {
+    locked_sha: 'c7c0ba17',
+    locked_decls: 749, locked_axioms: 14, locked_sorries: 163,
+    main_sha: '044eb098',   // Wave11–18 all merged (CF-22..28 + CUT-1 fwd), CI-green, drift-clean
+    wave910_sha: '66735bf',  // Wave9 PR #199 merged here; Wave10 PR #200 branched from it
+    experimental_decls: 1323, experimental_axioms: 23, experimental_axioms_unique: 22, experimental_sorries: 307,
+    toolchain: 'Lean v4.13.0 (locked) / v4.18.0 (Mathlib pinned) · main @ 044eb098',
+    locked_proven: ['F1', 'F4', 'F7', 'F11', 'F12', 'F18', 'F19', 'F22'],
+    experimental_count_approx: 119,  // waves 5–18 instilled card set (EXPERIMENTAL · CI-green, never folded into locked 8)
+    waves_merged: 'Wave5–23 (CF-1..28 + CUT-1 fwd + CUT-2 + Wave23 conditional BFT safety)',  // Wave15 CF-22, Wave16 CF-24/25/26, Wave17 CF-23/27/28, Wave18 CUT-1 forward fragment
+    cut2: 'Wave12 CUT-2 lambda_unique_of_separable — Λ uniqueness PROVEN CONDITIONAL on slice-multiplicativity, axiom-free, kernel-clean. Unconditional Λ stays Conjecture 1.',
+    bft_conditional: 'Wave23 khipu_quorum_safety_conditional — Khipu BFT safety (Conjecture 2) agreement / no-split-brain PROVEN CONDITIONAL on {n>=3f+1, honest non-equivocation}, axiom-clean (PR #214, merged main @ 43bcabb7). Unconditional BFT safety stays Conjecture 2 at the sharp boundary.',
+    slsa: 'Static space: SLSA L1 honest · product images (a11oy, killinchu) L2 build-attested (container provenance, Sigstore keyless) · L3 roadmap',
+    gpd: 'Governed Post-Determinism — SZL\u2019s own framework. The 5 organs ARE the participant-general model: the BRAIN reasons (divergent reasoning paths are OK), the HEART / YUYAY 13-axis gate certifies semantic admissibility (deny-by-default), the SKELETON / Khipu BFT quorum = Semantic Quorum Assurance (Wave23 conditional safety theorem; unconditional = Conjecture 2), and the CIRCULATORY / YAWAR append-only receipt bus = Epistemic State Replication + Verifiable Semantic Rollback (receipts/replay live; full ESR semantics = open R&D / roadmap). The unit of agreement shifts from identical output to certified semantic admissibility. Grounded entirely in SZL\u2019s prior DOI-stamped published work (Zenodo, Apr\u2013May 2026): The Loop Is the Product v1/v2 (10.5281/zenodo.19867281, .19934129), Lineage-Aware RAG v5 (.20020846), Sealed Constitutional Guardrails v6 (.20020845), Lutar Omega Formalism v4 (.20020841), SZL Doctrine v2 — 9 Canonical Axes (.20174600). Locked-proven = exactly 8 (locked_count_eight; F4/F7/F22 joined the original 5 on 2026-06-10); \u039b = Conjecture 1.'
+  };
+
+  /* ---- Maturity → chip styling ---- */
+  const MATURITY = {
+    LOCKED:        { label: 'LOCKED · kernel-verified', color: '#ffd166', desc: 'Sorry-free, Lean-core axioms only [propext, Classical.choice, Quot.sound]. Frozen @ c7c0ba17.' },
+    EXPERIMENTAL:  { label: 'EXPERIMENTAL · CI-green', color: '#5ad1ff', desc: 'Kernel-checked by CI on main @ 7885fd9. Additive — never folded into the locked 8.' },
+    AXIOM_GATED:   { label: 'AXIOM-GATED (disclosed)', color: '#c9a0ff', desc: 'Sorry-free given one declared, cited idealization (axiom listed in #print axioms).' },
+    CONDITIONAL:   { label: 'CONDITIONAL · axiom-free', color: '#9ef0c0', desc: 'A kernel-clean THEOREM proven CONDITIONAL on a stated stronger hypothesis (no new axiom). Honestly NOT an unconditional result.' },
+    CONJECTURE:    { label: 'CONJECTURE 1', color: '#ff7eb6', desc: 'Not a theorem. Conditional only within strengthened classes; unconditional uniqueness machine-checked FALSE.' }
+  };
+
+  /* =====================================================================
+     FORMULA LIBRARY — keyed by id. latex = ASCII-math the in-app renderer
+     converts to Unicode glyphs. axioms = verbatim #print axioms line.
+     ===================================================================== */
+  const FORMULAS = {
+    /* ---------- LOCKED PROVEN (exactly 8) ---------- */
+    F1: { id:'F1', name:'Replay-Hash Determinism', maturity:'LOCKED',
+      latex:'replay(s0, log) = trace  =>  replay(s0, log) = trace   (bit-identical)',
+      plain:'Replaying the SAME recorded log from the same initial state yields a BIT-IDENTICAL trace — no drift. Underpins the Khipu replay-hash gate.',
+      axioms:'f1_replay_fold_deterministic — [propext, Classical.choice, Quot.sound]',
+      ref:'lutar-lean PuriqFormulaLean.lean @ c7c0ba17' },
+    F11:{ id:'F11', name:'Ayni Reciprocity Conservation', maturity:'LOCKED',
+      latex:'fold(append_log) :  Sigma_in = Sigma_out   (tit-for-tat parity)',
+      plain:'Fold-replay of an append-only reciprocity log conserves the balance invariant (Axelrod–Hamilton tit-for-tat parity).',
+      axioms:'f11_ayni_reciprocity_conservation — [propext, Classical.choice, Quot.sound]',
+      ref:'lutar-lean PuriqFormulaLean.lean @ c7c0ba17' },
+    F12:{ id:'F12', name:'Kuramoto Coupling Boundedness (additive fragment)', maturity:'LOCKED',
+      latex:'| Sigma_i K_i(theta) |  <=  Sigma_i |K_i|   (bounded, additive)',
+      plain:'The discretised reciprocity coupling stays bounded under additive superposition. HONESTY CAVEAT: additive scaffolding ONLY — NOT the full nonlinear Kuramoto synchronization.',
+      axioms:'f12_* — [propext, Classical.choice, Quot.sound]',
+      ref:'lutar-lean @ c7c0ba17 · caveat in Lean docstring' },
+    F18:{ id:'F18', name:'Reed–Solomon RS(10,6) Recovery', maturity:'LOCKED',
+      latex:'recoverable(shards)  <=>  |surviving| >= 6   of 10',
+      plain:'Erasure tolerance: data is recoverable IFF at least 6 of 10 shards survive — the resilience arithmetic for the receipt/payload encoding.',
+      axioms:'f18_* — [propext, Classical.choice, Quot.sound]',
+      ref:'lutar-lean @ c7c0ba17' },
+    F19:{ id:'F19', name:'Bekenstein Additive Scaffolding', maturity:'LOCKED',
+      latex:'Sigma_r S(region_r)  <=  S(total)   (additive, monotone)',
+      plain:'Entropy budget is additive and monotone over a region partition (per-region ≤ total). HONESTY CAVEAT: monotone scaffolding ONLY — NOT the full Bekenstein bound S ≤ 2πkRE/(ℏc).',
+      axioms:'f19_* — [propext, Classical.choice, Quot.sound]',
+      ref:'lutar-lean @ c7c0ba17 · caveat in Lean docstring' },
+
+    F4: { id:'F4', name:'Khipu DAG Acyclicity Preservation', maturity:'LOCKED',
+      latex:'acyclic(G)  =>  acyclic(append_fresh_node(G))   (no back-edge cycle)',
+      plain:'Appending a fresh node to the Khipu receipt DAG preserves acyclicity — no receipt can ever cycle back on itself. Newly kernel-verified (joined the locked set 2026-06-10).',
+      axioms:'f4_khipu_dag_acyclic_preserved / f4_khipu_no_cycle / f4_khipu_reach_decreases / f4_khipu_append_preserves — no axioms (genuine, non-vacuous)',
+      ref:'lutar-lean ProvedFormulas.lean @ c7c0ba17 (lutar-lean #219 + platform #321)' },
+    F7: { id:'F7', name:'Chaski FIFO Reception Ordering', maturity:'LOCKED',
+      latex:'drain(enqueue_batch(c, msgs))  =  msgs   (reception order = send order)',
+      plain:'Messages drain from the Chaski channel in exactly the order sent — true FIFO, no reordering. Newly kernel-verified (joined the locked set 2026-06-10).',
+      axioms:'f7_chaski_fifo_order / f7_chaski_fifo_positional / f7_chaski_drain_eq — no axioms (genuine, non-vacuous)',
+      ref:'lutar-lean ProvedFormulas.lean @ c7c0ba17 (lutar-lean #219 + platform #321)' },
+    F22:{ id:'F22', name:'Khipu Emit Append-Only Monotonicity', maturity:'LOCKED',
+      latex:'emit(ledger)  =>  index(ledger\') > index(ledger)   (strictly increasing)',
+      plain:'Every Khipu emit strictly increases the ledger index — append-only, never rewrites history. Newly kernel-verified (joined the locked set 2026-06-10).',
+      axioms:'f22_khipu_emit_monotone / f22_emit_appends_length / f22_emit_strictly_greater — no axioms',
+      ref:'lutar-lean ProvedFormulas.lean @ c7c0ba17 (lutar-lean #219 + platform #321)' },
+
+    /* ---------- WAVE 8 (experimental, green on main @ 7885fd9) ---------- */
+    M2: { id:'M2', name:'Hash-Chain Tamper-Evidence', maturity:'EXPERIMENTAL',
+      latex:'H injective ,  p_i != q_i   =>   head(p) != head(q)',
+      plain:'For an injective hash step H, if any payload entry differs then the resulting head-hash differs — append-only hash chains are tamper-evident. The formal core behind receipt/audit-trail integrity.',
+      axioms:"Lutar.Wave8.HashChain.hashchain_tamper_evident — [propext]",
+      ref:'PR #196 @ b1c840f · Wave8/HashChain.lean' },
+    CP1:{ id:'CP1', name:'Conformal Marginal Coverage', maturity:'EXPERIMENTAL',
+      latex:'numer <= (n+1)*covCount  <  numer + (n+1)',
+      plain:'Split-conformal coverage satisfies a two-sided ⌈·⌉ bound — finite-sample, distribution-free marginal-coverage guarantee for the trust intervals on Λ.',
+      axioms:'Lutar.Wave8.Conformal.conformal_marginal_coverage — [propext, Quot.sound]',
+      ref:'PR #196 @ b1c840f · Wave8/Conformal.lean' },
+    B1: { id:'B1', name:'Byzantine Impossibility (n=3, f=1)', maturity:'EXPERIMENTAL',
+      latex:'3 <= 3*f   =>   no decider agrees with all-false AND all-true',
+      plain:'The classic 3-node / 1-fault Byzantine impossibility — the formal n ≥ 3f+1 lower bound. Justifies consensus/quorum sizing in the shared mesh and rejects under-provisioned fault tolerance.',
+      axioms:'Lutar.Wave8.Byzantine.byzantine_impossibility_3_1 — does not depend on any axioms',
+      ref:'PR #196 @ b1c840f · Wave8/Byzantine.lean' },
+    B2: { id:'B2', name:'Khipu BFT Safety (conditional)', maturity:'CONDITIONAL',
+      latex:'n>=3f+1  &&  honest non-equivocation  =>  two quorums certifying v1,v2  =>  v1 = v2',
+      plain:'Conjecture 2 (Khipu BFT safety) — agreement / no-split-brain PROVEN axiom-free CONDITIONAL on n>=3f+1 and honest non-equivocation under signed votes. Byzantine organs MAY equivocate in the model and safety still holds. Unconditional BFT safety stays Conjecture 2 at the sharp boundary.',
+      axioms:'Lutar.Wave23.QuorumSafety.khipu_quorum_safety_conditional — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #214 @ 43bcabb7 · Wave23/QuorumSafety.lean' },
+    S2: { id:'S2', name:'Simplex Safety Invariant', maturity:'EXPERIMENTAL',
+      latex:'RC safe ,  (mon pass => AC safe)   =>   forall t, state_t safe',
+      plain:'Simplex/RTA run-time-assurance: a monitored switch to a verified recovery controller keeps the system in the safe set for ALL time. Backbone of fail-safe autonomy and the HUKLLA deadman reflex.',
+      axioms:'Lutar.Wave8.Simplex.simplex_safety_invariant — [propext]',
+      ref:'PR #196 @ b1c840f · Wave8/Simplex.lean' },
+    G1: { id:'G1', name:'CPA Minimality', maturity:'EXPERIMENTAL',
+      latex:'cpaTime  =  argmin_t  sep2(t)   (unique minimizer)',
+      plain:'The closest-point-of-approach time is the UNIQUE minimizer of squared separation. Formal anchor for killinchu collision / conflict-risk timing.',
+      axioms:'Lutar.Wave8.CPA.cpa_unique — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #197 @ 7885fd9 · Wave8/CPA.lean' },
+    L2: { id:'L2', name:'Deny-by-Default Uniqueness', maturity:'EXPERIMENTAL',
+      latex:'D monotone & diagonal & conservative   =>   D == vmin  (everywhere)',
+      plain:'The min-gate vmin is the UNIQUE monotone, diagonal, conservative gate — the weakest-link trust gate is the ONLY policy satisfying the safety axioms; no permissive aggregator can sneak in. Backs the YUYAY deny-by-default conjunction.',
+      axioms:'Lutar.Wave8.MinGate.deny_by_default_unique — [propext]',
+      ref:'PR #196 @ b1c840f · Wave8/MinGate.lean' },
+    Q1: { id:'Q1', name:'Density-Matrix Mixture PSD', maturity:'EXPERIMENTAL',
+      latex:'Sigma_i w_i rho_i   PSD & unit-trace   (w_i>=0, Sigma w_i = 1)',
+      plain:'A convex combination of PSD, unit-trace matrices is again a valid density matrix — convexity of the mixed-state set. Underpins probabilistic ensemble reasoning in the YACHAY quantum-mind region.',
+      axioms:'Lutar.Wave8.DensityMixture.density_matrix_mixture — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #197 @ 7885fd9 · Wave8/DensityMixture.lean' },
+    Q2: { id:'Q2', name:'Gershgorin Governance Non-Degeneracy (real)', maturity:'EXPERIMENTAL',
+      latex:'Sigma_{j!=k} |W_kj| < |W_kk|   =>   det W != 0  =>  W x = b unique',
+      plain:'A strictly diagonally-dominant real governance weight matrix is invertible, so weighted aggregation has a unique solution — no zero-eigenvalue collapse of the governance operator. (ℂ variant left honestly as ROADMAP — shipped real-valued only, sorryAx-free.)',
+      axioms:'Lutar.Wave8.Gershgorin.governance_nonsingular_real — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #197 @ 7885fd9 · Wave8/Gershgorin.lean' },
+    L3: { id:'L3', name:'Λ Strict Monotonicity', maturity:'EXPERIMENTAL',
+      latex:'x_i > 0 ,  x <= y ,  x_k < y_k   =>   Lambda(x) < Lambda(y)',
+      plain:'The geometric-mean trust aggregator is per-component strictly monotone: improving any input strictly raises the fused trust. NO uniqueness of Λ asserted — Conjecture 1 untouched.',
+      axioms:'Lutar.Wave8.LambdaMono.gmean_strict_mono — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #197 @ 7885fd9 · Wave8/LambdaMono.lean' },
+    Ph1:{ id:'Ph1', name:'Axiom-Disclosure Soundness', maturity:'EXPERIMENTAL',
+      latex:'axiomsAllowed(S)   =>   every a in S is a Lean kernel axiom',
+      plain:'The axiom-disclosure gate is sound; locked_count_eight proves there are EXACTLY 8 locked entries with kernel-only axioms (= by decide, no axioms). Mechanically enforces "no hidden axioms".',
+      axioms:'Lutar.Wave8.AxiomDisclosure.disclosure_sound — [propext, Quot.sound] · locked_count_eight — no axioms',
+      ref:'PR #196 @ b1c840f · Wave8/AxiomDisclosure.lean' },
+
+    /* ---------- WAVE 9 + WAVE 10 (experimental, CI-green on main @ 66735bf) ----------
+       PR #199 (Wave9) merged @ 66735bf; Wave10 PR #200. EXPERIMENTAL · CI-green —
+       kernel-verified, NEVER folded into the locked 8. Λ stays Conjecture 1.
+       Live computation surfaces shipped in killinchu /api/killinchu/v1/wave910/*. */
+    W9_GERSH:{ id:'MA1', name:'Gershgorin Spectral Non-Degeneracy (incl. ℂ)', maturity:'EXPERIMENTAL',
+      latex:'strict diag dominance  =>  0 in no Gershgorin disc  =>  no zero eigenvalue  =>  W nonsingular',
+      plain:'Wave9 SPECTRAL Gershgorin: a strictly diagonally-dominant matrix (field-general, incl. ℂ) has no zero eigenvalue, hence is nonsingular and det is a unit. A cheap pre-flight gate on the governance/command-trust matrix BEFORE aggregation. DISTINCT from the Wave8 ℝ determinant-form card (Q2) — both kept.',
+      axioms:'Lutar.Wave9.Gershgorin.no_zero_eigenvalue / nonsingular_of_strict_diag_dominant / isUnit_det_of_strict_diag_dominant — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #199 @ 66735bf · Wave9/Gershgorin.lean' },
+    W9_CI:{ id:'OE-2', name:'Covariance-Intersection PSD Convex Closure', maturity:'EXPERIMENTAL',
+      latex:'P_ci^{-1} = w P_a^{-1} + (1-w) P_b^{-1}  =>  P_ci PSD & conservative',
+      plain:'Fuse two sensors that see the same target WITHOUT knowing their cross-covariance. The CI information matrix is PSD as a non-negative convex combination of PSD information matrices, so the fused covariance is always a valid, never-overconfident uncertainty. (Full inverted-covariance Loewner monotonicity left honestly as ROADMAP.)',
+      axioms:'Lutar.Wave9.CovarianceIntersection.posSemidef_convex_comb / ci_information_psd — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #199 @ 66735bf · Wave9/CovarianceIntersection.lean' },
+    W9_MENGER:{ id:'L-Menger', name:'Menger Cut/Path Duality (mesh redundancy)', maturity:'EXPERIMENTAL',
+      latex:'#edge-disjoint paths(s,t)  <=  minCut(s,t) ;  cut blocks reachability',
+      plain:'The number of edge-disjoint routes between two mesh nodes is bounded by the min-cut, and any cut blocks reachability. With k edge-disjoint paths the route survives any k-1 link failures — fail-safe routing, not a hope. (Full min-max Menger equality left honestly as ROADMAP.)',
+      axioms:'Lutar.Wave9.Menger.cut_blocks_reachable — [] · disjoint_paths_le_cut — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #199 @ 66735bf · Wave9/Menger.lean' },
+    W9_MERKLE:{ id:'CP-1', name:'Merkle Transparency-Log Soundness', maturity:'AXIOM_GATED',
+      latex:'Inj H  =>  inclusion proof re-derives root ; append-only root binding',
+      plain:'Every receipt is committed to a SHA-256 Merkle root; any single receipt\u2019s inclusion proof can be re-verified offline against that root, and the log is append-only. The transparency-log backbone for the YAWAR receipt bus. AXIOM-GATED: collision-resistance is an abstract HYPOTHESIS (Inj H) in Lean — SHA-256 is the concrete instance.',
+      axioms:'Lutar.Wave9.Merkle.merkle_root_binding / merkle_inclusion_sound / merkle_append_only — [propext] (Inj H hypothesis disclosed)',
+      ref:'PR #199 @ 66735bf · Wave9/Merkle.lean' },
+    W9_BDB:{ id:'C1', name:'Basilic Byzantine-BDB Threshold', maturity:'EXPERIMENTAL',
+      latex:'safe  <=>  n > 3t + d + 2q   (t Byzantine, d deceitful, q benign-faulty)',
+      plain:'A SHARPER fault threshold than the classic n > 3t: with t Byzantine, d deceitful and q benign-faulty nodes, safety holds iff n > 3t + d + 2q. The mesh needs fewer nodes for the same guarantee (quorum-sizing efficiency). (Full protocol-level solvability left honestly as ROADMAP.)',
+      axioms:'Lutar.Wave9.BasilicBDB.bdb_safe — [propext, Quot.sound] · bdb_threshold_dichotomy — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #199 @ 66735bf · Wave9/BasilicBDB.lean' },
+    W10_STL:{ id:'RA-1', name:'STL Robustness — two-sided Donzé–Maler', maturity:'EXPERIMENTAL',
+      latex:'Sat => rho >= 0 ;  rho > 0 => Sat ;  rho < 0 => violation   (NOT the iff Sat <=> rho>0)',
+      plain:'A runtime monitor that not only says pass/fail but computes a signed robustness margin ρ — how far a signal is from violating a maritime/drone C2 rule. The PROVEN guarantee is TWO-SIDED, NOT the naive iff Sat ↔ ρ>0 (FALSE at the ρ=0 boundary). Strengthens the HUKLLA deadman reflex with a sound margin.',
+      axioms:'Lutar.Wave10.STLRobustness.rho_sound / rho_pos_sound / rho_neg_violation — [propext, Quot.sound]',
+      ref:'PR #200 (Wave10) · Wave10/STLRobustness.lean' },
+    W10_REPLAY:{ id:'AU-1', name:'Replay-Determinism + Tamper Localization', maturity:'EXPERIMENTAL',
+      latex:'replay(log) == replay(log) ;  first divergence  =>  localizes tampered entry',
+      plain:'Replaying the same ordered receipt log yields the same final state, and if one entry is altered the audit pinpoints exactly which one (first divergence). Together with Merkle inclusion: a re-verifiable, tamper-localizing audit trail on YAWAR. Axiom-free core.',
+      axioms:'Lutar.Wave10.ReplayDeterminism.replay_deterministic — (none) · tamper_localized — (none) · replay_append — [propext, Quot.sound]',
+      ref:'PR #200 (Wave10) · Wave10/ReplayDeterminism.lean' },
+    W10_QUORUM:{ id:'CN-1', name:'Quorum-Intersection (Flexible Paxos)', maturity:'EXPERIMENTAL',
+      latex:'any two intersecting quorums  =>  unique decision  (no split-brain)',
+      plain:'If any two quorums intersect, no two quorums can ever decide differently — no split-brain in C2 consensus. Majority quorums always intersect (Flexible Paxos sizing). The agreement/unique-decision core depends on NO axioms.',
+      axioms:'Lutar.Wave10.QuorumIntersection.quorum_intersection_agreement / quorum_unique_decision — does not depend on any axioms · majority_quorums_intersect — [propext, Quot.sound]',
+      ref:'PR #200 (Wave10) · Wave10/QuorumIntersection.lean' },
+    W10_REACH:{ id:'MR-1', name:'Reachability-Redundancy (route monotonicity)', maturity:'EXPERIMENTAL',
+      latex:'add edge => reachability monotone ;  edge-avoiding reach  <=  full reach',
+      plain:'Adding links never removes reachability, and reachability that avoids a failed edge is bounded by full reachability — the monotonicity backbone that pairs with Menger to certify k-1 link-failure survival in the mesh. Axiom-free core.',
+      axioms:'Lutar.Wave10.ReachabilityRedundancy.reach_mono — (none) · avoiding_reach_le_full — (none)',
+      ref:'PR #200 (Wave10) · Wave10/ReachabilityRedundancy.lean' },
+
+    /* ---------- WAVE 11 (experimental, CI-green on main @ 044eb098) ----------
+       PR #201. EXPERIMENTAL · CI-green; #print axioms ⊆ {propext, Classical.choice, Quot.sound}.
+       Never folded into the locked 8. */
+    CF1:{ id:'CF-1', name:'Graph Auto-Distance Invariance', maturity:'EXPERIMENTAL',
+      latex:'phi graph automorphism  =>  d(phi u, phi v) = d(u, v)',
+      plain:'A graph automorphism preserves shortest-path distance — relabelling the mesh by a symmetry never changes routing distances. Structural invariant behind topology-aware routing.',
+      axioms:'Lutar.Wave11.GraphAutoDist.* — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #201 @ 044eb098 · Wave11' },
+    CF5:{ id:'CF-5', name:'Immune Neyman–Pearson Optimality', maturity:'EXPERIMENTAL',
+      latex:'likelihood-ratio test  =  most powerful at fixed false-alarm rate',
+      plain:'The CHAPAQ-style egress detector that thresholds a likelihood ratio is the most powerful test at any fixed false-alarm rate (Neyman–Pearson). The optimality basis for the immune inspector.',
+      axioms:'Lutar.Wave11.ImmuneNeymanPearson.* — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #201 @ 044eb098 · Wave11' },
+
+    /* ---------- WAVE 12 (experimental + CUT-2 conditional, CI-green on main @ 044eb098) ----------
+       PR #202. CUT-2 is a CONDITIONAL, axiom-free THEOREM — it gets Λ OFF bare conjecture
+       (conditional only). Unconditional Λ uniqueness stays Conjecture 1 (machine-checked FALSE). */
+    CUT2:{ id:'CUT-2', name:'Λ Conditional Uniqueness (slice-multiplicativity)', maturity:'CONDITIONAL',
+      latex:'Φ separable & per-axis multiplicative & monotone & A1A2A3A5  =>  Φ = Λ',
+      plain:'Λ uniqueness is PROVEN as a theorem CONDITIONAL on slice-multiplicativity (separability) — axiom-free and kernel-clean. This gets Λ OFF bare conjecture honestly. UNCONDITIONAL Λ uniqueness under bare A1–A5 stays Conjecture 1 (provably FALSE — maxAgg/min counterexamples). NOT folded into the locked 8.',
+      axioms:'Lutar.Round13.lambda_unique_of_separable — [propext, Classical.choice, Quot.sound] (NO new axiom)',
+      ref:'PR #202 @ 044eb098 · Round13/LambdaSeparable.lean' },
+    CF13:{ id:'CF-13', name:'DEQ Input-Lipschitz Well-Posedness', maturity:'EXPERIMENTAL',
+      latex:'dist(z*(x), z*(y))  <=  Lx/(1-K) · dist(x, y)',
+      plain:'A deep-equilibrium / fixed-point layer has a UNIQUE equilibrium that depends Lipschitz-continuously on its input with constant Lx/(1−K) — the model’s equilibrium reasoning is provably well-posed and stable to input perturbation. Margin badge for the code/forecast routing layer.',
+      axioms:'Lutar.Innovations.Round5.InputLipschitz.equilibrium_dist_le / equilibrium_lipschitz — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #202 @ 044eb098 · round5/OuroLoopInputLipschitz.lean' },
+    CF17:{ id:'CF-17', name:'Floating-Point Summation Error Bound', maturity:'EXPERIMENTAL',
+      latex:'|recSum(xs,δ) - Σxi|  <=  ((1+u)^(n-1) - 1) · Σ|xi|',
+      plain:'Recursive floating-point summation under the standard rounding model fl(a+b)=(a+b)(1+δ), |δ|≤u has a provable forward error bound (Higham §2.2). Numeric-stability badge for any aggregation/scoring sum.',
+      axioms:'Lutar.Khipu.NumericStability.recSum_error_le — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #202 @ 044eb098 · Khipu/NumericStability.lean' },
+
+    /* ---------- WAVE 13 (experimental, CI-green on main @ 044eb098) ----------
+       PR #203. PRNG completeness closed (−1 baseline sorry) + 2 experimental shadows. */
+    W13_REPLAY:{ id:'CF-RR', name:'Replay-Root Completeness', maturity:'EXPERIMENTAL',
+      latex:'s ∈ candidates ∧ IsReplayRoot(s)  =>  findReplayRoot(candidates).isSome',
+      plain:'If a valid replay-root exists among the candidates, the search provably finds one — the PRNG replay-root lookup is complete. Closed a baseline sorry; axioms {propext, Quot.sound}.',
+      axioms:'Lutar.PRNG.findReplayRoot_complete — [propext, Quot.sound]',
+      ref:'PR #203 @ 044eb098 · PRNG/K10v2_ReplayRoot.lean' },
+    W13_QUORUM:{ id:'CF-QV', name:'Quorum Single-Valued Vote (non-Byzantine shadow)', maturity:'EXPERIMENTAL',
+      latex:'n ≥ 3f+1 , two quorums (≥ n−f) , single-valued votes  =>  v1 = v2',
+      plain:'Under n ≥ 3f+1, any two large quorums of single-valued voters must agree — no split decision. HONEST SCOPE: this is the explicitly NON-Byzantine shadow (a faulty organ cannot equivocate here); it is NOT Khipu Conjecture 2, which stays OPEN.',
+      axioms:'Lutar.Wave13.Sweep.quorum_agreement_single_valued_vote — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #203 @ 044eb098 · Wave13/Sweep.lean' },
+    W13_HM:{ id:'CF-HM', name:'HLP Harmonic-Mean Bottleneck', maturity:'EXPERIMENTAL',
+      latex:'n / Σ(1/xi) < threshold  =>  ∃ i, xi < threshold',
+      plain:'If the harmonic mean of positive resources falls below a threshold, some single resource must be below it — a clean Hardy–Littlewood–Pólya bottleneck detector for the mesh. Clean inverse-form companion (no rpow).',
+      axioms:'Lutar.Wave13.Sweep.hm_bottleneck_clean — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #203 @ 044eb098 · Wave13/Sweep.lean' },
+
+    /* ---------- WAVE 14 (experimental frontier pack, CI-green on main @ 044eb098) ----------
+       PR #204. 9 kernel-clean theorems; all #print axioms ⊆ {propext, Classical.choice, Quot.sound}. */
+    CF18:{ id:'CF-18', name:'Mādhava / Leibniz Alternating-Series Remainder', maturity:'EXPERIMENTAL',
+      latex:'a antitone , Σ(-1)^i a_i -> L  =>  |Σ_{i<N}(-1)^i a_i - L|  <=  a_N',
+      plain:'For an alternating series with antitone terms, the truncation error is bounded by the first omitted term (Mādhava/Leibniz). Certified π/series error budget — you know exactly how many terms you need.',
+      axioms:'Lutar.Wave14.leibniz_remainder_bound / madhava_alt_series_bound_clean — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #204 @ 044eb098 · Wave14/LeibnizRemainder.lean' },
+    CF19:{ id:'CF-19', name:'Reed–Solomon MDS Distance Lower Bound', maturity:'EXPERIMENTAL',
+      latex:'distinct deg<k codewords  =>  disagree on ≥ n−k+1 of n points',
+      plain:'Two distinct degree-<k Reed–Solomon codewords differ in at least n−k+1 of n evaluation points — the achievability (lower) half of the Singleton/MDS distance bound. Underpins erasure resilience beyond the RS(10,6) locked card. HONEST: the upper bound / full MDS equality stays a sorry.',
+      axioms:'Lutar.Wave14.rs_distance_lower_bound / agreement_card_lt_of_degree_lt — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #204 @ 044eb098 · Wave14/ReedSolomonDistance.lean' },
+    CF20:{ id:'CF-20', name:'VCG Efficiency + Truthfulness Core', maturity:'EXPERIMENTAL',
+      latex:'∃ x* maximising social welfare ; truthful report weakly dominates',
+      plain:'An efficient (social-welfare-maximising) outcome always exists, and the VCG truthfulness core holds — honest reporting is the dominant strategy ingredient. Incentive-compatibility anchor for any auction/allocation surface.',
+      axioms:'Lutar.Wave14.exists_efficient_outcome / efficientOutcome_maximises / vcg_truthfulness_core — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #204 @ 044eb098 · Wave14/VCGEfficiency.lean' },
+    CF21:{ id:'CF-21', name:'Cover–Thomas Log-Sum + Gibbs Inequality', maturity:'EXPERIMENTAL',
+      latex:'Σa·log(Σa/Σb)  <=  Σ a·log(a/b) ;  Σp=Σq  =>  0 <= Σ p·log(p/q)',
+      plain:'The log-sum inequality and Gibbs’ inequality — the correctly-stated information-theory DPI core (Cover–Thomas Thm 2.7.1 / 2.6.3). HONEST: this does NOT repair the in-tree DPO klDivergence/pinsker, which stay FALSE-as-stated (no simplex hypothesis).',
+      axioms:'Lutar.Wave14.log_sum_inequality / gibbs_inequality — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #204 @ 044eb098 · Wave14/LogSumInequality.lean' },
+
+    /* ---------- WAVE 15 (experimental + CUT-1 bridge, CI-green on main @ 044eb098) ----------
+       PR #205. CF-22 conditionally repairs the FALSE-as-stated DPO axiom (axiom-free, ON the
+       simplex). All #print axioms ⊆ {propext, Classical.choice, Quot.sound}. The UNCONDITIONAL
+       DPO axiom klDivergence_nonneg stays FALSE-as-stated (token untouched). */
+    CF22:{ id:'CF-22', name:'DPO KL-Divergence Nonneg on the Simplex (conditional repair)', maturity:'EXPERIMENTAL',
+      latex:'p, q ∈ Δ  =>  KL(p‖q) = Σ p·log(p/q)  >=  0',
+      plain:'CONDITIONALLY repairs the FALSE-as-stated in-tree DPO axiom: KL ≥ 0 holds once p,q are constrained to the probability simplex (Gibbs). Live demo KL(P‖Q)=0.0880 ≥ 0 (χ²=0.1917). HONEST: the UNCONDITIONAL DPO axiom klDivergence_nonneg stays FALSE-as-stated — only the simplex-restricted statement is the theorem. Independent confirmation: χPO (arXiv:2407.13399), f-DPO (arXiv:2309.16240).',
+      axioms:'Lutar.Wave15.klDivergence_nonneg_simplex / dpo_klDivergence_nonneg_on_simplex — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #205 @ 044eb098 · Wave15/DPOKLSimplex.lean' },
+
+    /* ---------- WAVE 16 (experimental, CI-green on main @ 044eb098) ----------
+       PR #206. CF-24 geoBin satisfies FULL Aczél quasi-arithmetic axioms (real CUT-1 progress);
+       CF-25 Λ scale-invariance; CF-26 abacus place-value. 13 theorems, axiom-clean. */
+    CF24:{ id:'CF-24', name:'geoBin Full Aczél Quasi-Arithmetic Axioms', maturity:'EXPERIMENTAL',
+      latex:'geoBin: idempotent ∧ commutative ∧ homogeneous ∧ monotone  (Aczél QAM axioms)',
+      plain:'The geometric-binary mean satisfies the FULL Aczél quasi-arithmetic-mean axiom set (idempotency, commutativity, homogeneity, strict monotonicity) — real progress on the CUT-1 characterization route. Backs the per-axis generator form of the 13-axis Λ. Regularity-free QAM characterization (Burai–Kiss–Szokol, arXiv:2107.07391) shows bisymmetry yields continuity for free.',
+      axioms:'Lutar.Wave16.geoBin_idem / geoBin_comm / geoBin_homog / geoBin_mono — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #206 @ 044eb098 · Wave16/GeoBinAczel.lean' },
+    CF25:{ id:'CF-25', name:'Λ Scale-Invariance (affine reparam of generator)', maturity:'EXPERIMENTAL',
+      latex:'Λ(α·x + β)  invariant under affine reparam of the generator  (α>0)',
+      plain:'Λ is invariant under affine reparametrization of its quasi-arithmetic generator and under axis normalization — rescaling the trust axes leaves the Λ verdict fixed. Convex-duality backing (Nielsen, arXiv:2301.10980): QAMs are gradient maps of Legendre-type convex functions, equivariant under affine duality.',
+      axioms:'Lutar.Wave16.lambda_scale_axes / lambda_normalization_invariant — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #206 @ 044eb098 · Wave16/LambdaScaleInvariance.lean' },
+    CF26:{ id:'CF-26', name:'Abacus Place-Value Soundness', maturity:'EXPERIMENTAL',
+      latex:'Σ digit_i · base^i  =  value   (place-value encode/decode round-trip)',
+      plain:'Place-value (abacus) encoding and decoding round-trip exactly — a clean positional-number-system soundness lemma underpinning deterministic integer serialization in receipts.',
+      axioms:'Lutar.Wave16.abacus_place_value — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #206 @ 044eb098 · Wave16/Abacus.lean' },
+
+    /* ---------- WAVE 17 (experimental, CI-green on main @ 044eb098) ----------
+       PR #207. CF-23 FULL binary Pinsker (the long-sought headline); CF-27 monDEQ uniqueness;
+       CF-28 recurrent-depth Lipschitz. 24 theorems, axiom-clean. */
+    CF23:{ id:'CF-23', name:'Full Binary Pinsker Inequality', maturity:'EXPERIMENTAL',
+      latex:'2·(p − q)^2  <=  KL(Bern p ‖ Bern q)   (binary Pinsker)',
+      plain:'The full binary Pinsker inequality — KL ≥ 2·TV² for Bernoulli distributions — the long-sought headline result (previously only a named Lean axiom). Live demo KL=0.0823 ≥ 2·TV²=0.0800. Gives a confidence-margin bound for any binary gate. HONEST: still experimental CI-green tier, NOT folded into the locked 8.',
+      axioms:'Lutar.Wave17.binary_pinsker / binary_inv_sum_ge_four — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #207 @ 044eb098 · Wave17/BinaryPinsker.lean' },
+    CF27:{ id:'CF-27', name:'monDEQ Strong-Monotonicity ⇒ Unique Equilibrium', maturity:'EXPERIMENTAL',
+      latex:'F strongly monotone  =>  ∃! z*, F(z*) = z*   (unique fixed-point)',
+      plain:'A monotone deep-equilibrium operator that is strongly monotone has a UNIQUE equilibrium — the fixed-point reasoning layer is provably well-posed. Backs the uniqueness narrative for fusion fixed-points and tool-call resolution (Winston–Kolter monDEQ).',
+      axioms:'Lutar.Wave17.monDEQ_unique_equilibrium — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #207 @ 044eb098 · Wave17/MonDEQUnique.lean' },
+    CF28:{ id:'CF-28', name:'Recurrent-Depth Kʳ-Lipschitz Contraction', maturity:'EXPERIMENTAL',
+      latex:'r-fold recurrence with K-Lipschitz step  =>  Kʳ-Lipschitz overall',
+      plain:'An r-fold recurrent-depth block built from a K-Lipschitz step is Kʳ-Lipschitz overall — depth amplifies (K<1 ⇒ contraction; K>1 ⇒ honest blow-up bound). Stability budget for recurrent-depth estimators (mcleish7/retrofitting-recurrence, Apache-2.0).',
+      axioms:'Lutar.Wave17.recurrent_depth_lipschitz — [propext, Classical.choice, Quot.sound]',
+      ref:'PR #207 @ 044eb098 · Wave17/RecurrentDepthLipschitz.lean' },
+
+    /* ---------- WAVE 18 (CUT-1 FORWARD FRAGMENT — experimental + OPEN GAP, main @ 044eb098) ----------
+       19 axiom-clean theorems toward the CUT-1 unconditional Λ characterization. STILL CONDITIONAL:
+       the standing gap is `dyadic_image_dense` (the dense-domain step) — multi-week roadmap, NOT done.
+       Λ unconditional uniqueness stays Conjecture 1 (machine-checked FALSE). */
+    CUT1:{ id:'CUT-1', name:'CUT-1 Forward Fragment (generator unique up to affine)', maturity:'CONDITIONAL',
+      latex:'expMidpoint(x,y) = √(xy) ;  generator unique up to affine ;  cut1_conditional_lambda',
+      plain:'The forward fragment of the CUT-1 unconditional-uniqueness program: the generator is unique up to affine reparam, the exponential midpoint equals the geometric mean √(xy), and Λ follows CONDITIONALLY (19 axiom-clean theorems). HONEST OPEN GAP: `dyadic_image_dense` (the dense-domain density step, n-adic recursive construction per Kiss–Shulman 2026) is NOT proven — multi-week roadmap. Λ unconditional uniqueness stays Conjecture 1. NOT folded into the locked 8.',
+      axioms:'Lutar.Wave18.generator_unique_up_to_affine / expMidpoint_eq_geom / cut1_conditional_lambda — [propext, Classical.choice, Quot.sound] · GAP: dyadic_image_dense (open sorry, roadmap)',
+      ref:'PR #208 @ 044eb098 · Wave18/CUT1Forward.lean' },
+
+    /* ---------- EARLIER EXPERIMENTAL (waves 5-7 / agentic) ---------- */
+    W5_1:{ id:'W5-1', name:'AM–GM No-Inflation', maturity:'EXPERIMENTAL',
+      latex:'GM(x)  <=  AM(x)   (Lambda never inflates trust)',
+      plain:'Geometric mean ≤ arithmetic mean: the Λ aggregator can never inflate trust above the naive average.',
+      axioms:'wave-5 — 0 new axioms (Mathlib-dep CI-green)', ref:'PR #186 @ b71114cf' },
+    W7_5:{ id:'W7-5', name:'PAC-Bayes Routing Envelope', maturity:'EXPERIMENTAL',
+      latex:'R(rho)  <=  R_hat(rho) + sqrt( (KL(rho||pi)+ln(2/delta)) / 2m )',
+      plain:'A PAC-Bayes generalization envelope bounds true routing risk by empirical risk plus a KL complexity term — confidence on model routing.',
+      axioms:'wave-7 — 0 new axioms', ref:'PR #190 @ d6a232ba' },
+    P1: { id:'P1', name:'Receipt-Completeness', maturity:'EXPERIMENTAL',
+      latex:'every hop  =>  exactly one chained receipt   (no drop/reorder)',
+      plain:'Every hop in the governed loop leaves exactly one chained receipt — no silent drop or reorder.',
+      axioms:'agentic-loop — axiom-free core', ref:'PR #188 @ 2ede47a2' },
+    P3: { id:'P3', name:'Non-Interference (Goguen–Meseguer)', maturity:'EXPERIMENTAL',
+      latex:'poisoned retrieval   =/=>   flip(DENY -> ALLOW)',
+      plain:'Poisoned / untrusted retrieval provably CANNOT flip a DENY to ALLOW (Cannonico bullseye).',
+      axioms:'P3 — PROVEN, axiom-free core', ref:'PR #188 @ 2ede47a2' },
+    P4: { id:'P4', name:'Replay-Determinism (loop)', maturity:'EXPERIMENTAL',
+      latex:'rerun(recorded)  =>  byte-identical receipt chain',
+      plain:'Re-running a recorded run reproduces a byte-identical receipt chain.',
+      axioms:'P4 — PROVEN, axiom-free', ref:'PR #188 @ 2ede47a2' },
+    P5: { id:'P5', name:'Tamper-Evidence (loop)', maturity:'AXIOM_GATED',
+      latex:'mutate(any receipt)  =>  re-verify REJECTS',
+      plain:'Any single-receipt mutation makes re-verify reject. AXIOM-GATED on hashFn_collision_resistant (NIST FIPS 180-4, disclosed).',
+      axioms:'P5 — AXIOM-GATED [hashFn_collision_resistant]', ref:'PR #188 @ 2ede47a2' }
+  };
+
+  /* =====================================================================
+     ORGANS — anatomical placement. pos = [x,y,z] in a single body's local
+     frame (y up = head, y down = feet; chest ~ +0.6, head ~ +2.4).
+     The two bodies are translated ±X in app.js. `system` keys into SYSTEMS.
+     ===================================================================== */
+  // Region tags drive color: heart, blood, brain, nerve, skeleton, gate, audit, mesh
+  const ORGANS = [
+    /* HEART — YUYAY (the beating Λ center, shared) */
+    { key:'yuyay', system:'heart', quechua:'YUYAY', fn:'13-axis CONJUNCTIVE truth gate',
+      pos:[0,0.55,0.18], scale:0.42, color:'#ff5d8f', shared:true, beat:true,
+      blurb:'Every proposal (thought · action · tool call) clears 13 axes CONJUNCTIVELY or is rejected and receipted. pass = all(score[i] >= floor[i]) — NOT a weighted average. 0.94 on moralGrounding FAILS even if all other 12 = 1.00. Emits the Λ-signed receipt. The beating Λ heart = geometric-mean trust over the axes.',
+      formulas:['CUT2','CUT1','CF25','CF24','L3','L2','CP1','W5_1','CF21'],
+      lambda_note:true,
+      axes:'A01 moralGrounding≥0.95 · A02 measurabilityHonesty≥0.95 · A03 empiricalGrounding≥0.90 · A04 logicalConsistency≥0.90 · A05 sourceTransparency≥0.90 · A06 reproducibility≥0.90 · A07 licenseHygiene≥0.90 · A08 scopeDiscipline≥0.90 · A09 claimCalibration≥0.90 · A10 evalAwareness · A11 deceptionKeywords · A12 conflictingDirectives · A13 reversalDirective(STOP→halt)' },
+
+    /* BRAIN — YACHAY cortex (read-only reasoning cortex), at the head */
+    { key:'amaru', system:'brain', quechua:'YACHAY', fn:'read-only reasoning cortex (5 regions + quantum mind) · proposer',
+      pos:[0,2.35,0.05], scale:0.5, color:'#7c5cff',
+      blurb:'The cortex hangs off the bus by a SINGLE tether: it READS frozen snapshots, NEVER WRITES — the thinking layer cannot tamper with the record. 5 regions: PREFRONTAL (the 13-axis wisdom gate = the heart) · FRONTAL (proposer = RIMAY) · TEMPORAL (retrieval/RAG) · PARIETAL (K-candidate sim = MUSQUY) · OCCIPITAL (tool surface = MCP) · QUANTUM MIND (ρ 4×4, λ_min ≥ 0.225).',
+      formulas:['Q1','Q2','W7_5','W9_CI','W9_GERSH','CF13','CF17','CF18','CF22','CF27','CF28'] },
+
+    /* CIRCULATORY / BLOOD — YAWAR (the vessel network spine), chest→abdomen */
+    { key:'yawar', system:'blood', quechua:'YAWAR', fn:'append-only SHA-256 receipt bus',
+      pos:[0,-0.15,0.2], scale:0.34, color:'#ff3b5c',
+      blurb:'h = sha256(json.dumps(packet, sort_keys=True)).hexdigest() → appended as [hash, packet]; never mutated, never deleted. Every component READS from YAWAR (snapshots frozen per layer). This is the audit-truth: you cannot rewrite history.',
+      formulas:['M2','P1','F18','F1','W9_MERKLE','W10_REPLAY','CF19','W13_REPLAY','CF26'] },
+    { key:'ruway', system:'blood', quechua:'RUWAY', fn:'sole authorized write surface',
+      pos:[-0.34,-0.05,0.16], scale:0.2, color:'#ff7a6b',
+      blurb:'The ONLY authorized write surface. Every ceremonial write commits through RUWAY; all writes traverse CHAPAQ egress inspection. D-YAWAR-FLOW enforced.',
+      formulas:['P4','F11'] },
+    { key:'sentra', system:'blood', quechua:'CHAPAQ', fn:'egress immune inspector',
+      pos:[0.34,-0.05,0.16], scale:0.2, color:'#ff9e6b',
+      blurb:'Egress immune inspector — 6 signatures + DoS guard (~18 SLOC). All writes traverse CHAPAQ before reaching the bus. The body\u2019s immune checkpoint at the vessel wall.',
+      formulas:['P5','M2','CF5'] },
+
+    /* NERVOUS SYSTEM — span propagation + HUKLLA reflex */
+    { key:'huklla', system:'nerve', quechua:'HUKLLA', fn:'deadman tripwire (reflex arc)',
+      pos:[0,1.5,-0.18], scale:0.18, color:'#5ad1ff',
+      blurb:'DEADMAN REFLEX ARC: HUKLLA tripwire fires → span context frozen at pre-cycle value → halt signal into the HATUN root span → all child spans cancelled. The spinal reflex that halts the organism on anomaly.',
+      formulas:['S2','B1','W10_STL','W9_MENGER','W10_REACH','W13_HM','CF23'] },
+    { key:'vsp', system:'nerve', quechua:'VSP / OTel', fn:'span lineage (efferent · afferent · proprioceptive)',
+      pos:[0,1.0,-0.22], scale:0.2, color:'#5ad1ff',
+      blurb:'W3C TraceContext: trace_id · span_id · parent_span_id propagate brain → every effector. Replay verifier checks child.parent_span_id == parent.span_id across a cycle. 3 nerve classes: EFFERENT (motor HATUN→YACHAY→YUYAY) · AFFERENT (sensory YAWAR→HATUN) · PROPRIOCEPTIVE (self-monitor R0513→HATUN).',
+      formulas:['P4','F1'] },
+
+    /* GOVERNANCE / SKELETON anchors */
+    { key:'hatun', system:'skeleton', quechua:'HATUN', fn:'sovereign orchestrator + seal (the crown)',
+      pos:[0,2.95,0], scale:0.26, color:'#ffd166',
+      blurb:'Sovereign orchestrator (~199 SLOC): long-horizon multi-subagent dispatch, energy-gated (Butler–Volmer), doctrine-gated (YUYAY per cycle), cryptographic receipts on YAWAR. SOVEREIGN SEAL: identity-trace to a HUMAN PRINCIPAL · 10-tripwire egress · byte-deterministic commit · 5× replay verified. The seal also enforces the AXIOM-DISCLOSURE honesty gate (Ph1): exactly 8 locked-proven, no hidden axioms.',
+      formulas:['Q2','P1','Ph1','W9_GERSH','W10_QUORUM','W9_BDB','CF20','W13_QUORUM','CF1'] },
+    { key:'overwatch', system:'audit', quechua:'R0513 / OVERWATCH', fn:'read-only 5-invariant audit',
+      pos:[0,0.1,-0.24], scale:0.2, color:'#9ef0c0',
+      blurb:'5 invariants, READ-ONLY: I1 KL drift · I2 joint margin · I3 TUKUY re-gate · I5 Maxwell rigidity · I6 continuum-hash chain. Event-log lines only; does NOT halt or gate; CRITICAL alerts notify the operator.',
+      formulas:['M2','B1','CP1','W9_MERKLE','W10_REPLAY'] },
+    { key:'tukuy', system:'skeleton', quechua:'TUKUY', fn:'egress actuator',
+      pos:[0.3,-1.6,0.05], scale:0.16, color:'#ffd166',
+      blurb:'Egress actuator (~70 SLOC). The hand that acts on the world only after YUYAY passes and CHAPAQ clears — re-gated by R0513 invariant I3.',
+      formulas:['S2','G1'] },
+    { key:'musquy', system:'brain', quechua:'MUSQUY', fn:'K-candidate simulation (parietal)',
+      pos:[-0.28,1.95,0.0], scale:0.16, color:'#7c5cff',
+      blurb:'K-candidate simulation (~219 SLOC) in the PARIETAL region — imagines K futures, scores each through the gate, never commits until YUYAY passes.',
+      formulas:['Q1','W7_5'] }
+  ];
+
+  /* =====================================================================
+     SYSTEMS legend (the five) + governance overlay
+     ===================================================================== */
+  const SYSTEMS = [
+    { key:'heart',     name:'HEART',            organ:'YUYAY v3',          fn:'13-axis conjunctive critique gate · emits Λ-signed receipt', color:'#ff5d8f' },
+    { key:'blood',     name:'CIRCULATORY / BLOOD', organ:'YAWAR',          fn:'append-only SHA-256 receipt bus · RUWAY sole write · CHAPAQ egress', color:'#ff3b5c' },
+    { key:'brain',     name:'BRAIN',            organ:'YACHAY cortex',     fn:'read-only reasoning cortex · 5 regions + quantum mind · single tether, reads snapshots', color:'#7c5cff' },
+    { key:'nerve',     name:'NERVOUS SYSTEM',   organ:'OTel / VSP spans',  fn:'efferent · afferent · proprioceptive · HUKLLA deadman reflex', color:'#5ad1ff' },
+    { key:'skeleton',  name:'SKELETON',         organ:'12 service repos',  fn:'axial spine = doctrine+receipt chain · appendicular = capability bones', color:'#ffd166' }
+  ];
+
+  /* =====================================================================
+     TWO BODIES — one circulatory + nervous mesh
+     ===================================================================== */
+  const BODIES = [
+    { key:'a11oy', name:'a11oy', side:-1, color:'#3fe0c5',
+      blurb:'governed-AI decision body — model routing, deny-by-default policy, human-on-the-loop actuation, signed-receipt Khipu DAG.' },
+    { key:'killinchu', name:'killinchu', side:1, color:'#ffb13f',
+      blurb:'maritime / drone C2 body — track classification, ROE gate under human authority, detect·classify·defeat, DSSE receipt per interdiction, 3-of-4 BFT quorum.' }
+  ];
+
+  /* The 12-bone axial spine + appendicular skeleton repos (skeleton legend) */
+  const SKELETON_REPOS = {
+    axial: ['szl-yawar (receipt bus)', 'doctrine core (receipt chain)'],
+    appendicular: ['szl-brain (YACHAY cortex+QM)','szl-overwatch (R0513)','szl-wires (YAWAR↔OTel)','szl-rimay (NL filter)','szl-sentra (egress)','szl-tupu-t7 (receipt-token)','szl-chakana (21-edge lattice)','szl-terra (BodyGraph)','szl-brand (assets)','szl-musquy (K-sim)']
+  };
+
+
+  /* =====================================================================
+     PUTNAM 2025 — honest doctrine-v11 kernel verdict (additive)
+     Locked-8 {F1,F4,F7,F11,F12,F18,F19,F22} + Λ = Conjecture 1 are UNCHANGED by this block.
+     Numbers match the CI kernel run on lutar-lean main exactly.
+     ===================================================================== */
+  const PUTNAM_2025 = {
+    competition:'86th William Lowell Putnam Mathematical Competition (Dec 6 2025)',
+    source:'lutar-lean main', kernel_sha:'b7c3e382d56f6548945d93895c9d78c6411c40f8', kernel_sha_short:'b7c3e38', computed:'2026-06-09', doctrine:'v11',
+    headline:'0 REAL / 11 DEMO / 1 OPEN',
+    tally:{ REAL:0, DEMO:11, OPEN:1 },
+    labels:{ REAL:'Lean-kernel checked, no sorry, no extra axioms beyond declared', DEMO:'compiles but uses sorry/unproven lemmas', OPEN:'statement only' },
+    bridge:'We are not doing "drones solve Putnam." We are doing: Intelligence → Structure → Conjecture → Certificate. killinchu supplies intelligence (tracking, fusion, ROE decisions, signed receipts). We extract mathematical structure (graphs, constraints, optimization instances). We pose Putnam-grade + SZL-native problems. We ship certificates (Lean-verified REAL theorems, reproducible benchmarks, provenance).',
+    problems:[
+      {id:'A1',file:'Lutar/Putnam/P_A1.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'A2',file:'Lutar/Putnam/P_A2.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'A3',file:'Lutar/Putnam/P_A3.lean',status:'OPEN',note:'statement only (True-shell); official answer withheld pending a real proof'},
+      {id:'A4',file:'Lutar/Putnam/P_A4.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'A5',file:'Lutar/Putnam/P_A5.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'A6',file:'Lutar/Putnam/P_A6.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'B1',file:'Lutar/Putnam/P_B1.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'B2',file:'Lutar/Putnam/P_B2.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'B3',file:'Lutar/Putnam/P_B3.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'B4',file:'Lutar/Putnam/P_B4.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'B5',file:'Lutar/Putnam/P_B5.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'},
+      {id:'B6',file:'Lutar/Putnam/P_B6.lean',status:'DEMO',note:'formalized statement; proof uses sorry/unproven lemmas'}
+    ],
+    szl_native:{ ids:['SZL-12A','SZL-12B'], status:'PENDING', note:'SZL-native originals — pending upstream kernel work; not yet on lutar-lean main' },
+    note:'A3 is OPEN (statement-only True-shell); the official 2025 A3 answer is intentionally withheld here until a REAL proof exists. No problem is currently REAL: each DEMO file formalizes the statement but discharges the proof with sorry or unproven lemmas.'
+  };
+
+  /* =====================================================================
+     ============================  v5 QUANTUM-BIO LAYER  =================
+     ADDITIVE. A self-contained, sovereign JS implementation of the FOUR
+     tiny verified quantum-bio formulas (closed-form), mirroring the LIVE
+     a11oy endpoints /api/a11oy/v1/qbio/{coherence,pmf,compass,lambda}.
+     Labeled "verified model (mirrors a11oy /api/a11oy/v1/qbio)". 0 runtime
+     CDN, 0 network: the math is embedded here so the layer is honest and
+     self-contained even when the cross-origin endpoint is unreachable.
+
+     HONESTY (doctrine v11) — never violated:
+       • Lindblad coherence, Mitchell single-ion pmf, radical-pair compass,
+         Becker/Nernst = [VERIFIED] (executed, peer-grounded physics).
+       • Two-ion K⁺/H⁺ correction + Λ-v5 closure floor = [PROPOSED] SZL
+         engineering constructs. Λ-v5 is an ENGINEERING gate, explicitly
+         NOT the formal uniqueness Λ (which stays Conjecture 1, machine-
+         checked FALSE unconditional).
+       • Jack Kruse light/water/magnetism framing = [NARRATIVE] only.
+       • Adds NO locked theorem — locked-proven stays exactly 8
+         {F1,F4,F7,F11,F12,F18,F19,F22}. Trust never 100%.
+     ===================================================================== */
+  const QBIO = (function(){
+    'use strict';
+    var R = 8.314, F = 96485.0, T = 310.0;
+
+    /* 1. Lindblad / GKSL coherence decay (VERIFIED). C(t)=C0·e^(-t/τc). */
+    function coherenceAt(t, tau_c, C0){
+      tau_c = (tau_c==null) ? 6.05 : tau_c;
+      C0 = (C0==null) ? 1.0 : C0;
+      return C0 * Math.exp(-t / tau_c);
+    }
+    function coherenceSeries(tau_c, C0, tMax, n){
+      tau_c = (tau_c==null)?6.05:tau_c; C0=(C0==null)?1.0:C0;
+      tMax = (tMax==null)?(tau_c*3):tMax; n=(n==null)?48:n;
+      var out=[]; for(var i=0;i<n;i++){ var t=(i/(n-1))*tMax; out.push({t:t, C:coherenceAt(t,tau_c,C0)}); }
+      return out;
+    }
+
+    /* 2. Mitchell proton-motive force (VERIFIED single-ion; two-ion=PROPOSED).
+       Δp = ΔΨ − (2.3RT/F)·ΔpH (mV). d_psi in mV, d_pH/d_pK dimensionless. */
+    function pmf(d_psi, d_pH){ return d_psi - (2.3*R*T/F)*d_pH*1000.0; }
+    function pmfTwoIon(d_psi, d_pH, d_pK, w){ // [PROPOSED] K⁺/H⁺ correction
+      w=(w==null)?0.18:w; return (1-w)*pmf(d_psi,d_pH) + w*pmf(d_psi,d_pK);
+    }
+
+    /* 3. Becker/Nernst bioelectricity (VERIFIED — classical electrophysiology). */
+    function nernst(Co, Ci, z){ z=(z==null)?1:z; return (R*T)/(z*F)*Math.log(Co/Ci)*1000.0; }
+    function currentOfInjury(V, Rohm){ return V/Rohm; } // amps (V in volts, R in ohms)
+
+    /* 4. Radical-pair magnetic compass — angular singlet yield (VERIFIED).
+       HONEST: the toy cos(ωt) model FAILS (~0.003). This is the single-
+       nucleus closed-form (contrast ~0.025, matches a11oy /qbio/compass);
+       the FULL density-matrix model gives ~0.378. We label both honestly. */
+    function radicalPairYield(B_uT, thetaRad){
+      // Closed-form single-nucleus singlet yield Φ_S(θ): an honest, monotone
+      // surrogate of the full spin-Hamiltonian eigen-evolution. B in microtesla.
+      var b = (B_uT==null?50:B_uT)/50.0;            // normalize to geomagnetic ~50µT
+      var c = Math.cos(thetaRad);
+      // singlet yield rises toward field-parallel; bounded in (0,1)
+      var phi = 0.5 + 0.0125*b*(2*c*c - 1);          // amplitude tuned to ~0.025 contrast
+      return Math.max(0, Math.min(1, phi));
+    }
+    function compassContrast(B_uT, angsRad){
+      angsRad = angsRad || [0, Math.PI/6, Math.PI/3, Math.PI/2];
+      var ys = angsRad.map(function(a){ return radicalPairYield(B_uT,a); });
+      var lo=Math.min.apply(null,ys), hi=Math.max.apply(null,ys);
+      return { yields:ys, contrast:(hi-lo), lo:lo, hi:hi,
+               full_model:0.378 /* full density-matrix model, VERIFIED */ };
+    }
+
+    /* 5. Λ-v5 CLOSURE FLOOR per node [PROPOSED engineering gate].
+       lambdaV5 = coherence · charge.  EXECUTE iff lambdaV5 >= lam_min (0.25),
+       else RECHARGE/RE-TUNE. Mirrors the 3 Lean theorems:
+         decohered (C=0) never closes; uncharged (charge=0) never closes;
+         Λ monotone in coherence. */
+    function lambdaV5(C, charge){ return C * charge; }
+    function closureGate(C, charge, lam_min){
+      lam_min=(lam_min==null)?0.25:lam_min;
+      var v = lambdaV5(C, charge);
+      return { value:v, lam_min:lam_min, execute:(v >= lam_min),
+               verdict:(v >= lam_min ? 'EXECUTE' : 'RECHARGE / RE-TUNE') };
+    }
+
+    /* canonical headline numbers (match a11oy /qbio/summary, verified) */
+    var CONST = {
+      tau_c: 6.05,
+      pmf_single_mV: 119.3,
+      pmf_two_ion_mV: 121.5,        // master payload §3/§10 headline (PROPOSED two-ion)
+      compass_contrast_closed: 0.025,
+      compass_contrast_full: 0.378,
+      nernst_K_mV: -89.0,
+      injury_current_uA: 70,
+      lam_min: 0.25,
+      lifecycle: '7 EXECUTE / 13 RECHARGE (balanced, self-regulating)'
+    };
+    return { coherenceAt, coherenceSeries, pmf, pmfTwoIon, nernst, currentOfInjury,
+             radicalPairYield, compassContrast, lambdaV5, closureGate, CONST,
+             label:'verified model (mirrors a11oy /api/a11oy/v1/qbio)' };
+  })();
+
+  /* ---- Field leaders (VERIFIED load-bearing) + status doctrine ---- */
+  const QBIO_LEADERS = [
+    { name:'Peter Mitchell', work:'Chemiosmosis / proton-motive force (Nobel 1978)', status:'VERIFIED' },
+    { name:'Nick Lane', work:'Energy gradients precede genes (origin of life)', status:'VERIFIED' },
+    { name:'Douglas Wallace', work:'Bioenergetics ↔ mitochondrial genome', status:'VERIFIED' },
+    { name:'Klaus Schulten', work:'Radical-pair magnetoreception founder (cryptochrome)', status:'VERIFIED' },
+    { name:'Peter Hore', work:'Radical-pair spin dynamics (PNAS 2009)', status:'VERIFIED' },
+    { name:'Robert O. Becker', work:'DC current of injury → regeneration (classical)', status:'VERIFIED' },
+    { name:'Jack Kruse', work:'Light·Water·Magnetism framing (mitochondria as quantum engines)', status:'NARRATIVE' }
+  ];
+
+  /* ---- Sources (arXiv / DOI / PMC) for the v5 layer ---- */
+  const QBIO_SOURCES = [
+    { label:'Mitchell pmf (Nobel)', url:'https://pmc.ncbi.nlm.nih.gov/articles/PMC2662253', status:'VERIFIED' },
+    { label:'Two-ion K⁺/H⁺ correction (Function zqac012)', url:'https://journals.physiology.org/doi/full/10.1093/function/zqac012', status:'PROPOSED' },
+    { label:'Lane — origin energy (arXiv:2104.08076)', url:'https://arxiv.org/abs/2104.08076', status:'VERIFIED' },
+    { label:'Wallace 2010 (PMC3245717)', url:'https://pmc.ncbi.nlm.nih.gov/articles/PMC3245717', status:'VERIFIED' },
+    { label:'Lindblad path integral (arXiv:2603.10839)', url:'https://arxiv.org/abs/2603.10839', status:'VERIFIED' },
+    { label:'Open quantum systems (arXiv:2202.05203)', url:'https://arxiv.org/abs/2202.05203', status:'VERIFIED' },
+    { label:'Radical pair (ora.ox.ac.uk uuid:d6b5f84e)', url:'https://ora.ox.ac.uk/', status:'VERIFIED' },
+    { label:'Schulten cryptochrome', url:'https://www.ks.uiuc.edu/Research/cryptochrome/', status:'VERIFIED' },
+    { label:'Hore PNAS 2009 (10.1073/pnas.0711968106)', url:'https://www.pnas.org/doi/10.1073/pnas.0711968106', status:'VERIFIED' },
+    { label:'Robert O. Becker (The Body Electric)', url:'https://en.wikipedia.org/wiki/Robert_O._Becker', status:'VERIFIED' },
+    { label:'AdS/CFT — holographic principle (Maldacena)', url:'https://en.wikipedia.org/wiki/Holographic_principle', status:'NARRATIVE' }
+  ];
+
+  /* ---- 3 Lean closure theorems mirrored from the master payload §12 ---- */
+  const QBIO_THEOREMS = [
+    { id:'QB-T1', name:'Decohered never closes', status:'VERIFIED (Lean, no sorry)',
+      lean:'theorem decohered_never_closes (h0:n.coherence=0)(hpos:lamMin>0): ¬ closureOk n lamMin',
+      plain:'If coherence C=0 then lambdaV5 = 0 < lam_min, so the node can NEVER close — a fully decohered organ never executes.' },
+    { id:'QB-T2', name:'Uncharged never closes', status:'VERIFIED (Lean, no sorry)',
+      lean:'theorem uncharged_never_closes (h0:n.charge=0)(hpos:lamMin>0): ¬ closureOk n lamMin',
+      plain:'If charge=0 then lambdaV5 = 0 < lam_min, so an uncharged organ never executes — "no charge, no execute".' },
+    { id:'QB-T3', name:'Λ monotone in coherence', status:'VERIFIED (Lean, no sorry)',
+      lean:'theorem lambda_mono_in_coherence (hq:q≥0)(h:c1≤c2): lambdaVal ⟨c1,q⟩ ≤ lambdaVal ⟨c2,q⟩',
+      plain:'For charge q≥0, raising coherence never lowers lambdaV5 — the closure floor is monotone in coherence.' }
+  ];
+
+  /* =====================================================================
+     PER-ORGAN v5 SEEDING (ADDITIVE — mutates each ORGAN object in place,
+     adds new fields; NEVER removes/renames an existing field). Each value
+     is COMPUTED from the verified formulas above using per-organ inputs
+     derived deterministically from the organ index + name (so the same
+     organ always shows the same physically-plausible state). The mV
+     numbers are computed, not fabricated; the per-organ INPUTS are a
+     labeled SAMPLE physiological assignment (organs have no measured pmf).
+     ===================================================================== */
+  (function seedOrgansV5(){
+    // sample per-organ membrane inputs (labeled SAMPLE), within physiological ranges
+    function hashStr(s){ var h=2166136261; for(var i=0;i<s.length;i++){ h^=s.charCodeAt(i); h=Math.imul(h,16777619); } return (h>>>0); }
+    ORGANS.forEach(function(o, idx){
+      var hh = hashStr(o.key);
+      // age along the coherence decay curve: 0..~2·τc (SAMPLE), deterministic per organ
+      var age = ((hh % 1000)/1000) * (QBIO.CONST.tau_c * 1.6);
+      var C = QBIO.coherenceAt(age, QBIO.CONST.tau_c, 1.0);
+      // SAMPLE membrane inputs (physiological ranges): ΔΨ ~ 140..165 mV,
+      // ΔpH ~ 0.28..0.61, ΔpK ~ 0.17..0.40 (deterministic per-organ, labeled SAMPLE)
+      var d_psi = 140 + (hh % 26);                 // ~140..165 mV
+      var d_pH  = 0.28 + ((hh>>5) % 34)/100;        // ~0.28..0.61
+      var d_pK  = 0.17 + ((hh>>9) % 24)/100;        // ~0.17..0.40
+      var dp_single = QBIO.pmf(d_psi, d_pH);        // VERIFIED Mitchell
+      var dp_two   = QBIO.pmfTwoIon(d_psi, d_pH, d_pK); // PROPOSED two-ion
+      var dp0 = QBIO.CONST.pmf_two_ion_mV;          // reference Δp0 = 121.5 mV
+      var charge = dp_two / dp0;                    // normalized charge ratio
+      var gate = QBIO.closureGate(C, charge, QBIO.CONST.lam_min);
+      o.qbio = {
+        sample:true,                                // per-organ INPUTS are a labeled SAMPLE
+        age_units: +age.toFixed(3),
+        coherence: +C.toFixed(4),                   // C(age)=e^(-age/τc)  [VERIFIED math]
+        tau_c: QBIO.CONST.tau_c,
+        d_psi_mV: d_psi, d_pH: +d_pH.toFixed(3), d_pK: +d_pK.toFixed(3),
+        pmf_single_mV: +dp_single.toFixed(2),       // [VERIFIED Mitchell]
+        pmf_two_ion_mV: +dp_two.toFixed(2),         // [PROPOSED two-ion K⁺/H⁺]
+        charge: +charge.toFixed(4),                 // Δp_two / Δp0
+        lambdaV5: +gate.value.toFixed(4),           // coherence · charge  [PROPOSED gate]
+        lam_min: QBIO.CONST.lam_min,
+        execute: gate.execute,
+        verdict: gate.verdict
+      };
+    });
+  })();
+
+  /* ---- 5 v5 quantum-bio FORMULA CARDS (ADDITIVE to FORMULAS; honest tags).
+     These are NOT locked theorems and are NEVER folded into the locked 8.
+     maturity uses the existing MATURITY palette where it fits; the cards'
+     plain text carries the explicit VERIFIED/PROPOSED/NARRATIVE status. ---- */
+  FORMULAS.QB_COH = { id:'QB-COH', name:'Lindblad Coherence Decay', maturity:'EXPERIMENTAL',
+    latex:'C(t) = C0 \u00b7 e^(-t / tau_c) ,  tau_c \u2248 6.05',
+    plain:'[VERIFIED math] Open-quantum-system (Lindblad/GKSL) coherence decays exponentially with time-constant \u03c4c\u22486.05. Steady state d\u03c1/dt=0 = proof of closure. This is a verified model mirroring a11oy /api/a11oy/v1/qbio/coherence \u2014 it adds NO locked theorem.',
+    axioms:'verified model (mirrors a11oy /api/a11oy/v1/qbio/coherence) \u2014 not a Lean theorem',
+    ref:'Lindblad path integral arXiv:2603.10839 \u00b7 open quantum systems arXiv:2202.05203' };
+  FORMULAS.QB_PMF = { id:'QB-PMF', name:'Mitchell Proton-Motive Force (+ two-ion)', maturity:'AXIOM_GATED',
+    latex:'\u0394p = \u0394\u03a8 \u2212 (2.3 RT/F)\u00b7\u0394pH ;  two-ion: 119.3 \u2192 121.5 mV',
+    plain:'[VERIFIED] single-ion Mitchell pmf (chemiosmosis, Nobel). [PROPOSED] K\u207a/H\u207a two-ion correction (w\u22480.18) lifts 119.3\u2192121.5 mV. The bioenergetic "charge" of each organ = \u0394p/\u0394p0. Mirrors a11oy /api/a11oy/v1/qbio/pmf.',
+    axioms:'verified model (mirrors a11oy /qbio/pmf); two-ion correction = PROPOSED SZL construct',
+    ref:'Mitchell PMC2662253 \u00b7 two-ion Function zqac012 \u00b7 Wallace PMC3245717' };
+  FORMULAS.QB_COMPASS = { id:'QB-COMPASS', name:'Radical-Pair Magnetic Compass', maturity:'EXPERIMENTAL',
+    latex:'\u03a6_S(\u03b8) angular singlet yield ;  contrast \u2248 0.025 (closed) / 0.378 (full)',
+    plain:'[VERIFIED math] Radical-pair spin dynamics give an angular singlet-yield contrast that biases execution direction (a magnetic compass). HONEST: the toy cos(\u03c9t) model FAILS (~0.003); single-nucleus closed form \u2248 0.025; only the full density-matrix model reaches \u2248 0.378. Mirrors a11oy /qbio/compass.',
+    axioms:'verified model (mirrors a11oy /qbio/compass) \u2014 not a Lean theorem',
+    ref:'Schulten cryptochrome (ks.uiuc.edu) \u00b7 Hore PNAS 2009 10.1073/pnas.0711968106' };
+  FORMULAS.QB_LAMBDA = { id:'QB-\u039bv5', name:'\u039b-v5 Closure Floor (engineering gate)', maturity:'CONJECTURE',
+    latex:'lambdaV5 = coherence \u00b7 charge  \u2265  lam_min (0.25)  \u21d2  EXECUTE, else RECHARGE',
+    plain:'[PROPOSED engineering gate] A node may execute iff it is coherent AND charged (lambdaV5 \u2265 0.25), else it RECHARGES / re-tunes. EXPLICITLY NOT the formal uniqueness \u039b \u2014 that stays Conjecture 1 (machine-checked FALSE unconditional). Mirrored by 3 Lean closure theorems (decohered/uncharged never close; \u039b monotone in coherence). Adds NO locked theorem; trust never 100%.',
+    axioms:'PROPOSED engineering gate; Lean closure theorems QB-T1..T3 (no sorry); \u039b uniqueness = Conjecture 1 (FALSE)',
+    ref:'master payload \u00a77/\u00a712 \u00b7 mirrors a11oy /api/a11oy/v1/qbio/lambda' };
+  FORMULAS.QB_BECKER = { id:'QB-BECKER', name:'Becker / Nernst Bioelectricity', maturity:'EXPERIMENTAL',
+    latex:'E = (RT/zF) ln([ion]o/[ion]i) ;  Nernst K\u207a = \u221289.0 mV ;  I = V/R = 70 \u00b5A',
+    plain:'[VERIFIED \u2014 classical electrophysiology] Nernst potential (K\u207a 5/140 mM = \u221289.0 mV) and Becker\u2019s DC "current of injury" (70 mV across 1 k\u03a9 = 70 \u00b5A) that directs growth/healing. The bioelectric drive behind the v5 layer; not a quantum claim.',
+    axioms:'verified model (classical electrophysiology) \u2014 not a Lean theorem',
+    ref:'Robert O. Becker, The Body Electric (1985) \u00b7 en.wikipedia.org/wiki/Robert_O._Becker' };
+
+  /* attach the 5 v5 cards to the relevant organs (ADDITIVE — push only) */
+  (function attachV5Cards(){
+    function pushUniq(o, ids){ if(!o) return; o.formulas = o.formulas || []; ids.forEach(function(id){ if(o.formulas.indexOf(id)<0) o.formulas.push(id); }); }
+    var byKey={}; ORGANS.forEach(function(o){ byKey[o.key]=o; });
+    pushUniq(byKey['amaru'],  ['QB_COH','QB_COMPASS']);   // cortex / quantum mind
+    pushUniq(byKey['yuyay'],  ['QB_LAMBDA']);             // Λ heart → Λ-v5 gate
+    pushUniq(byKey['yawar'],  ['QB_PMF']);                // bioenergetic charge of the bus
+    pushUniq(byKey['ruway'],  ['QB_BECKER']);             // write surface / bioelectric drive
+  })();
+
+  /* =====================================================================
+     ============================  v6 AGENTIC-GPU ORGANS  ===============
+     ADDITIVE. 5 new organs grown from the agentic-GPU energy engine
+     (platform PRs #370 harvest, #371 budget, #372 security, #373 runner).
+     Honesty doctrine v11 LOCKED — same rules as all prior blocks:
+       • Locked-proven stays EXACTLY 8 {F1,F4,F7,F11,F12,F18,F19,F22}.
+       • Λ = Conjecture 1 (advisory, NEVER "proven trust").
+       • Khipu BFT = Conjecture 2 (only conditional proven, Wave23).
+       • Maturity labels (LOCKED/EXPERIMENTAL/CONDITIONAL/AXIOM_GATED/CONJECTURE)
+         NEVER inflated — every new formula is EXPERIMENTAL.
+       • Energy joules are SAMPLE values until on-box NVML is live.
+       • "Sovereign" only on own metal; resource-map tier for flare/space.
+       • No free-energy claims.
+     Quechua identity:
+       KALLPA (energy/power), WAQAYCHAQ (guardian/immune),
+       KAMAY (give-power / schedule), SAMAY (breath),
+       RIKUY (see/perceive) — each paired with plain-English FUNCTION.
+     ===================================================================== */
+
+  /* ---- 5 new EXPERIMENTAL formula cards for the agentic-GPU layer ---- */
+  FORMULAS.AG_LANDAUER = { id:'AG-LANDAUER', name:'Landauer Erasure Floor (EXPERIMENTAL)', maturity:'EXPERIMENTAL',
+    latex:'E_erase >= k_B T ln 2   (per bit erased)',
+    plain:'[EXPERIMENTAL] Every irreversible bit-erasure costs at least k\u2082T\u00b7ln\u202f2 joules (Landauer 1961, Bennett 1982). Sets the MINIMUM energy budget per compute step; actual GPU joules are far above this floor. HONEST: joules here are SAMPLE values \u2014 on-box NVML is not yet wired to this viewer; real-time measurement is platform roadmap. Backs the METABOLISM organ energy-harvest narrative. NOT a locked theorem \u2014 additive EXPERIMENTAL only.',
+    axioms:'physics postulate \u2014 not a Lean theorem; Landauer 1961 Phys.Rev. 183 p.183; Bennett 1982 Int.J.Theor.Phys. 21 p.905',
+    ref:'platform #370 harvest endpoint \u00b7 a-11-oy.com/api/a11oy/v1/harvest/metrics' };
+
+  FORMULAS.AG_HARVEST = { id:'AG-HARVEST', name:'Harvest Budget Constraint (EXPERIMENTAL)', maturity:'EXPERIMENTAL',
+    latex:'W_batch <= harvest_budget(t)   (wasted-energy bounded batch)',
+    plain:'[EXPERIMENTAL] Batch work admitted is bounded by the available wasted-energy harvest budget at time t (grid curtailment, wind surplus, flare gas, etc.). An engineering inequality \u2014 not a Lean theorem. Backs the METABOLISM and RESPIRATORY organs. HONEST: budget is a platform engineering signal, not a proved energy-conservation law. Platform PR #371.',
+    axioms:'engineering constraint \u2014 not a Lean theorem; platform #371 harvest_budget.py',
+    ref:'platform #371 \u00b7 harvest_budget.py \u00b7 a-11-oy.com/api/a11oy/v1/harvest/metrics' };
+
+  FORMULAS.AG_EGRESS = { id:'AG-EGRESS', name:'Anti-SSRF Egress Allowlist + Consent Gate (EXPERIMENTAL)', maturity:'EXPERIMENTAL',
+    latex:'egress(url) => url in allowlist  &&  consent_given   (deny-by-default)',
+    plain:'[EXPERIMENTAL] Outbound requests are allowed ONLY if the destination URL is on the static egress allowlist AND explicit swarm-node consent was given. Any call failing either check is rejected at the boundary. Deny-by-default \u2014 the immune layer. Backed by CF-5 (Neyman\u2013Pearson immune gate, EXPERIMENTAL) and L2 (Deny-by-Default Uniqueness, EXPERIMENTAL). Platform PR #372.',
+    axioms:'engineering allowlist policy \u2014 not a Lean theorem; pairs with CF5 Neyman\u2013Pearson (EXPERIMENTAL) and L2 deny-by-default (EXPERIMENTAL)',
+    ref:'platform #372 security \u00b7 CHAPAQ egress inspector \u00b7 szl-sentra repo' };
+
+  FORMULAS.AG_POSTURE = { id:'AG-POSTURE', name:'Energy-Posture Scheduler Signal (EXPERIMENTAL)', maturity:'EXPERIMENTAL',
+    latex:'posture in {negative-price, curtailed, cheap, normal}   =>   batch_admit_gate',
+    plain:'[EXPERIMENTAL] The energy posture \u2014 derived from real-time price/curtailment signals \u2014 is the "hormone" that opens or closes the proactive-batch admission gate. Reactive requests NEVER starve regardless of posture. HONEST: this is a policy signal derived from grid data, not a measured physical quantity. Platform PR #373 runner.',
+    axioms:'engineering policy signal \u2014 not a Lean theorem; ties to aWattar price feed and Energy-Charts curtailment data',
+    ref:'platform #373 runner \u00b7 aWattar API \u00b7 Energy-Charts API \u00b7 szl-platform repo' };
+
+  FORMULAS.AG_OUROBOROS = { id:'AG-OUROBOROS', name:'Ouroboros Soak-Loop Bound (EXPERIMENTAL)', maturity:'EXPERIMENTAL',
+    latex:'soak_cycles <= ouroboros_bound   (no hyperventilation)',
+    plain:'[EXPERIMENTAL] The soak loop (inhale wasted energy \u2192 exhale back to reactive) is bounded by the Ouroboros loop-depth limit \u2014 it cannot hyperventilate (admit unbounded batch). Backs the RESPIRATORY organ. Platform PR #371 harvest_budget + Ouroboros depth bound in szl-platform. HONEST: engineering loop-depth cap, not a proved convergence theorem.',
+    axioms:'engineering loop-depth cap \u2014 not a Lean theorem; pairs with F19 Bekenstein additive scaffolding (LOCKED) as the conceptual budget envelope',
+    ref:'platform #371 \u00b7 Ouroboros loop-bound \u00b7 szl-platform repo' };
+
+  /* ---- 5 new AGENTIC-GPU ORGANS (ADDITIVE to ORGANS array) ---- */
+  ORGANS.push(
+    /* METABOLISM — KALLPA (energy/power): wasted-energy harvest engine */
+    { key:'kallpa', system:'metabolism', quechua:'KALLPA', fn:'wasted-energy harvest (grid/wind/tidal/flare/space feeds)',
+      pos:[0.55,-0.35,0.22], scale:0.22, color:'#f5a623',
+      blurb:'Converts wasted external energy into compute work. Ingests live harvest metrics (grid curtailment, wind surplus, tidal, flare gas, space feeds) from a-11-oy.com/api/a11oy/v1/harvest/metrics. Ties to F19 Bekenstein additive scaffolding (LOCKED \u2014 monotone entropy budget) and the AG-LANDAUER Landauer floor (EXPERIMENTAL). HONEST: joules here are SAMPLE values \u2014 on-box NVML is not yet wired to this anatomy viewer; real-time energy measurement is a platform roadmap item. Sovereign only on own metal; resource-map tier for flare/space (map, not capture). Platform PR #370.',
+      formulas:['F19','AG_LANDAUER','AG_HARVEST'],
+      energy_note:true },
+
+    /* IMMUNE SYSTEM — WAQAYCHAQ (guardian): egress allowlist + consent-only swarm gate */
+    { key:'waqaychaq', system:'immune', quechua:'WAQAYCHAQ', fn:'deny-by-default egress guard + consent-only swarm gate',
+      pos:[-0.55,-0.35,0.22], scale:0.22, color:'#7ed321',
+      blurb:'Rejects un-allowlisted egress and un-consented swarm nodes. Three layers: (1) anti-SSRF static egress allowlist \u2014 un-allowlisted outbound URL = instant reject; (2) secret-leak guard \u2014 scans outbound payloads for credential patterns; (3) consent-only swarm gate \u2014 a new mesh node must obtain explicit consent before admission. Deny-by-default (L2 EXPERIMENTAL). Backed by CF-5 Neyman\u2013Pearson immune gate (EXPERIMENTAL) \u2014 the most powerful fixed-false-alarm-rate test. Platform PR #372.',
+      formulas:['CF5','L2','AG_EGRESS'] },
+
+    /* ENDOCRINE — KAMAY (give-power / command): energy-posture hormonal scheduler */
+    { key:'kamay', system:'endocrine', quechua:'KAMAY', fn:'energy-posture scheduler \u2014 hormone gates proactive batch admission',
+      pos:[0,-0.75,0.26], scale:0.19, color:'#bd10e0',
+      blurb:'The energy posture (negative-price / curtailed / cheap / normal) is the \"hormone\" that gates proactive batch admission. When posture = negative-price or curtailed, the KAMAY hormone opens wide for batch work; when normal, it narrows. Reactive requests NEVER starve regardless of posture. HONEST: this is a policy signal derived from real-time grid-price and curtailment data \u2014 not a measured joule, not a proved theorem. Ties to the preemptive scheduler (platform PR #373) and the AG-POSTURE engineering signal.',
+      formulas:['AG_POSTURE','AG_HARVEST'] },
+
+    /* RESPIRATORY — SAMAY (breath): soak-loop breath with wasted-energy windows */
+    { key:'samay', system:'respiratory', quechua:'SAMAY', fn:'soak-loop breath \u2014 inhale on wasted_energy=1, exhale to reactive-only',
+      pos:[0,-0.50,0.30], scale:0.20, color:'#4a90e2',
+      blurb:'The soak loop \u201cbreathe\u201d with wasted-energy windows: INHALE (admit Bekenstein-bounded batch) when wasted_energy=1 (curtailed/negative-price); EXHALE (drain to reactive-only) otherwise. Ouroboros-bounded \u2014 the loop cannot hyperventilate (no unbounded batch). Ties to F19 Bekenstein additive scaffolding (LOCKED) as the conceptual entropy-budget envelope, harvest_budget (AG-HARVEST EXPERIMENTAL), and Ouroboros loop-depth cap (AG-OUROBOROS EXPERIMENTAL). Platform PRs #370, #371.',
+      formulas:['F19','AG_HARVEST','AG_OUROBOROS'],
+      samay_note:true },
+
+    /* SENSES / EYES — RIKUY (see/perceive): global external feed perception */
+    { key:'rikuy', system:'senses', quechua:'RIKUY', fn:'global feed perception \u2014 price/renewable/frequency/flare/solar/wind',
+      pos:[0,1.75,0.30], scale:0.18, color:'#50e3c2',
+      blurb:'The body\u2019s perception of wasted energy in the world. Five feed families: (1) aWattar \u2014 day-ahead hourly electricity prices (negative-price detection); (2) Energy-Charts \u2014 renewable fraction + grid frequency (curtailment detection); (3) NASA VIIRS \u2014 flared-gas satellite (resource-map, not capture \u2014 HONEST: identifying stranded-gas locations, no physical capture from orbit); (4) NOAA L1 \u2014 solar-wind data (space-weather context); (5) Open-Meteo \u2014 wind/tidal forecast (renewable intermittency). Tier: resource-map for flare/space (map, not capture); feed-signal for the others. Backs the KAMAY hormone and SAMAY breath timing. HONEST: raw data feeds, not a proved formula.',
+      formulas:['AG_POSTURE','AG_HARVEST'] }
+  );
+
+  /* ---- 5 new AGENTIC-GPU SYSTEMS entries (ADDITIVE to SYSTEMS array) ---- */
+  SYSTEMS.push(
+    { key:'metabolism', name:'METABOLISM',    organ:'KALLPA',     fn:'wasted-energy harvest \u00b7 F19 Bekenstein (LOCKED) + Landauer floor (EXPERIMENTAL) \u00b7 joules SAMPLE until on-box NVML', color:'#f5a623' },
+    { key:'immune',     name:'IMMUNE',        organ:'WAQAYCHAQ',  fn:'deny-by-default egress allowlist + secret-leak guard + consent-only swarm gate \u00b7 Neyman\u2013Pearson (EXPERIMENTAL)', color:'#7ed321' },
+    { key:'endocrine',  name:'ENDOCRINE',     organ:'KAMAY',      fn:'energy-posture hormonal scheduler \u00b7 policy signal, not a measured joule \u00b7 platform PR #373', color:'#bd10e0' },
+    { key:'respiratory',name:'RESPIRATORY',   organ:'SAMAY',      fn:'soak-loop breath \u00b7 inhale on wasted_energy=1, exhale to reactive-only \u00b7 Ouroboros-bounded (EXPERIMENTAL)', color:'#4a90e2' },
+    { key:'senses',     name:'SENSES / EYES', organ:'RIKUY',      fn:'global feed perception \u00b7 aWattar price \u00b7 Energy-Charts \u00b7 NASA VIIRS flare (resource-map) \u00b7 NOAA solar-wind \u00b7 Open-Meteo', color:'#50e3c2' }
+  );
+
+  /* =====================================================================
+     ========================  v5 (EVOLVES v4)  ========================
+     ADDITIVE. New organs + overlays that surface the governed conscience
+     (WILLAY), the Sovereign Mesh as a circulatory upgrade, the buyer-
+     verifiable receipt bloodstream, the 8 locked-proven → organ map, the
+     AI-Assurance (WDP/CDAO) artifact map, and the yarqa + thermal-PINN
+     physics layer. Honesty doctrine v11 LOCKED is UNCHANGED:
+       • Locked-proven stays EXACTLY 8 {F1,F4,F7,F11,F12,F18,F19,F22} @ c7c0ba17.
+       • Λ = Conjecture 1 (advisory heart-gate, NEVER a theorem).
+       • Khipu BFT = Conjecture 2 (Wave23 conditional only).
+       • Every LIVE/MEASURED/MODELED/SAMPLE/ROADMAP label is honest — a node
+         that does not answer reads DOWN, never a fabricated green light.
+     ===================================================================== */
+
+  /* ---- v5 live read-only endpoints (all on the a11oy origin; in CSP allow-list) ---- */
+  const V5_ENDPOINTS = {
+    willay:    'https://szlholdings-a11oy.hf.space/api/a11oy/v1/willay/classifiers',
+    mesh:      'https://szlholdings-a11oy.hf.space/api/a11oy/v1/govern/health',
+    ledger:    'https://szlholdings-a11oy.hf.space/api/lake/v1/health',
+    receipts:  'https://szlholdings-a11oy.hf.space/api/lake/v1/receipts?limit=1',
+    cosign:    'https://szlholdings-a11oy.hf.space/cosign.pub',
+    assurance: 'https://szlholdings-a11oy.hf.space/assurance'
+  };
+
+  /* ---- v5 organs (ADDITIVE to ORGANS array) ---- */
+  ORGANS.push(
+    /* CONSCIENCE / IMMUNE-GATE — WILLAY: inspectable signed refusals.
+       Plain-English function label; tamper-EVIDENT, not tamper-proof. */
+    { key:'willay', system:'conscience', quechua:'WILLAY', fn:'conscience / immune-gate — inspectable signed refusals',
+      pos:[0,0.30,0.34], scale:0.20, color:'#39d8c8', willay_note:true,
+      blurb:'The governed conscience. Five INSPECTABLE classifiers (cyber · bio dual-use · hidden-reasoning extraction · prompt-injection / governance bypass · self-harm) gate every proposal; each refusal discloses its category, pattern intent, rationale, and lineage and is signed on the receipt bus. Trust ceiling 0.97 — trust is never 100%. HONEST: refusals are tamper-EVIDENT (you can detect alteration via the signed receipt), NOT tamper-proof. The inverse of a removed/hidden safety classifier: ours are auditable rules, not opaque weights. Reads ' + V5_ENDPOINTS.willay + ' live; honest empty-state if unreachable.',
+      formulas:['CF5','L2','AG_EGRESS'] },
+
+    /* SOVEREIGN MESH — circulatory upgrade. The 3D node is an anchor; the
+       LIVE per-node truth (tower LIVE / laptop / GLM honest-DOWN) is read
+       from /govern/health into the mesh panel and is NEVER fabricated. */
+    { key:'sovereign_mesh', system:'mesh', quechua:'SOVEREIGN MESH', fn:'circulatory upgrade — governed inference mesh (live per-node)',
+      pos:[0,-0.32,-0.26], scale:0.20, color:'#ff7a9c', mesh_note:true,
+      blurb:'The circulatory system upgraded to a sovereign inference mesh. Each node (tower RTX 4060 Ti anchor · laptop · GLM engine) is rendered with its HONEST live/down status read from ' + V5_ENDPOINTS.mesh + ': a node that is offline reads DOWN — never a fabricated green light. Per-node F11 Ayni reciprocity contribution (LOCKED) keeps the mesh balanced tit-for-tat. VRAM-fusion across nodes is ROADMAP — today the mesh is a scheduler / router (“Smart Routing”), not a fused address space. Energy joules are UNAVAILABLE unless a live NVML meter answers; never fabricated.',
+      formulas:['F11','F7','F22'] }
+  );
+
+  /* ---- v5 SYSTEMS entries (ADDITIVE) ---- */
+  SYSTEMS.push(
+    { key:'conscience', name:'CONSCIENCE / IMMUNE-GATE', organ:'WILLAY', fn:'5 inspectable signed-refusal classifiers · trust ceiling 0.97 · tamper-EVIDENT not tamper-proof', color:'#39d8c8' },
+    { key:'mesh',       name:'SOVEREIGN MESH',           organ:'governed inference mesh', fn:'circulatory upgrade · live per-node up/down (never fabricated) · F11 Ayni per node · VRAM-fusion ROADMAP', color:'#ff7a9c' }
+  );
+
+  /* =====================================================================
+     v5 — 8 LOCKED-PROVEN → ORGAN MAP (additive, honest)
+     The mapping is presentational only: it does NOT change the locked set,
+     which stays EXACTLY 8 {F1,F4,F7,F11,F12,F18,F19,F22} @ c7c0ba17.
+     Each entry shows the verbatim Lean statement (latex) + #print axioms.
+     Λ is the heart-gate: ADVISORY, Conjecture 1, NEVER a theorem.
+     Khipu BFT safety is Conjecture 2 (Wave23 conditional only).
+     ===================================================================== */
+  const LEAN_MAP = {
+    kernel_sha:'c7c0ba17',
+    verified_note:'kernel-verified sorry-free @ c7c0ba17',
+    organs:[
+      { organ:'BRAIN',       organ_key:'amaru',  color:'#7c5cff', formulas:['F1'],
+        why:'F1 Replay-Hash Determinism underpins the read-only reasoning cortex: replaying a recorded log is bit-identical, so the thinking layer can never drift the record.' },
+      { organ:'HEART',       organ_key:'yuyay',  color:'#ff5d8f', formulas:['F4','F11'],
+        why:'F4 (Khipu DAG acyclicity) + F11 (Ayni reciprocity conservation) sit at the beating gate. Λ is the heart-gate — ADVISORY, Conjecture 1, never a theorem.' },
+      { organ:'CIRCULATORY', organ_key:'yawar',  color:'#ff3b5c', formulas:['F7','F22'],
+        why:'F7 (FIFO reception ordering — “Smart Routing”) + F22 (emit append-only monotonicity) keep the receipt bloodstream ordered and append-only.' },
+      { organ:'NERVOUS',     organ_key:'vsp',    color:'#5ad1ff', formulas:['F12'],
+        why:'F12 Kuramoto coupling boundedness (additive fragment) bounds the nervous-system span coupling — additive scaffolding only, NOT full nonlinear sync.' },
+      { organ:'SKELETON',    organ_key:'hatun',  color:'#ffd166', formulas:['F18','F19'],
+        why:'F18 (RS(10,6) erasure recovery) + F19 (Bekenstein additive scaffolding) are the skeletal resilience + entropy-budget bones.' }
+    ],
+    lambda:'Λ = heart-gate, ADVISORY = Conjecture 1. Unconditional uniqueness under A1–A5 is machine-checked FALSE; CUT-2 proves uniqueness only CONDITIONAL on slice-multiplicativity. Never a theorem.',
+    khipu:'Khipu BFT safety = Conjecture 2. Wave23 proves agreement CONDITIONAL on n≥3f+1 + honest non-equivocation; unconditional safety stays Conjecture 2.'
+  };
+
+  /* =====================================================================
+     v5 — AI-ASSURANCE (WDP / CDAO) ARTIFACT MAP (additive, honest)
+     Maps each organ to the assurance artifact it satisfies, with honest
+     status chips. Aligns to the live a11oy /assurance surface.
+     Status vocabulary (honest): LIVE · PARTIAL · ROADMAP.
+     ===================================================================== */
+  const ASSURANCE_MAP = {
+    surface:V5_ENDPOINTS.assurance,
+    note:'Maps each organ to the AI-assurance artifact it satisfies (WDP / CDAO framing). Status chips are honest: LIVE = the artifact exists and is reachable; PARTIAL = exists but incomplete / sampled; ROADMAP = planned, not yet real.',
+    rows:[
+      { organ:'BRAIN / cortex',        organ_key:'amaru',  artifact:'Model card', status:'PARTIAL',
+        detail:'Read-only reasoning cortex; open-weight engine identity disclosed via /govern/health. Full model card is PARTIAL (engine + tier disclosed; eval suite roadmap).' },
+      { organ:'HEART / gate',          organ_key:'yuyay',  artifact:'TEVV signed receipt', status:'LIVE',
+        detail:'Test/Evaluation/Verification/Validation: every gate verdict is a DSSE ECDSA-P256 signed receipt on the bus — verifiable offline against cosign.pub.' },
+      { organ:'CIRCULATORY / bus',     organ_key:'yawar',  artifact:'SI-7 hash-chain (integrity)', status:'LIVE',
+        detail:'NIST SI-7 software/information integrity: the receipt ledger is a sha3_256 hash-chain (chain_head live at /api/lake/v1/health). Append-only, tamper-evident.' },
+      { organ:'CONSCIENCE / immune',   organ_key:'willay', artifact:'Data card + safety classifiers', status:'LIVE',
+        detail:'Five inspectable refusal classifiers with disclosed lineage (live at /willay/classifiers). Honest data-card framing: categories + rationale disclosed; trust ceiling 0.97.' },
+      { organ:'NERVOUS / OTel',        organ_key:'vsp',    artifact:'OTel-GenAI monitoring', status:'PARTIAL',
+        detail:'W3C TraceContext span lineage across the agent loop; OpenTelemetry GenAI semantic conventions are PARTIAL (span lineage live; full GenAI attribute coverage roadmap).' },
+      { organ:'SKELETON / supply-chain', organ_key:'hatun', artifact:'SBOM / SLSA provenance', status:'PARTIAL',
+        detail:'This static Space is SLSA L1 honest; product images (a11oy, killinchu) are L2 build-attested (Sigstore keyless, Rekor-anchored). SBOM + L3 are ROADMAP.' },
+      { organ:'MESH',                  organ_key:'sovereign_mesh', artifact:'TEVV per-node attestation', status:'PARTIAL',
+        detail:'Per-node up/down attested live from /govern/health (never fabricated). Per-node signed attestation + VRAM-fusion provenance is ROADMAP.' }
+    ]
+  };
+
+  /* =====================================================================
+     v5 — yarqa CFD + THERMAL-PINN physics overlay (additive, honest)
+     Composes the existing yarqa plug-flow compartmentalization (a clean-room
+     engineering-method CFD, NOT a locked theorem) with a thermal physics-
+     informed-NN model into ONE "physics-governed" layer. Label: MODELED
+     (not measured), bounded error. NEVER counted among the locked 8.
+     ===================================================================== */
+  const PHYSICS_OVERLAY = {
+    label:'MODELED',
+    headline:'physics-governed layer = yarqa CFD plug-flow ⊕ thermal PINN',
+    honest:'MODELED, not measured. This composes the existing yarqa compartmental plug-flow CFD (engineering method, off-by-default in the dissection dock) with a thermal physics-informed neural-network surrogate. It is NOT a locked theorem and is NEVER folded into the locked-8 — data.js stays the single source of truth and the locked-proven count is unchanged at 8.',
+    components:[
+      { name:'yarqa CFD plug-flow', kind:'compartmental advection (region-grown)',
+        detail:'Clean-room plug-flow compartmentalization over the existing circulatory / receipt flow sampled from data.js. Emits a reproducible integrity digest. Read-only overlay.' },
+      { name:'thermal PINN surrogate', kind:'physics-informed NN (steady-state heat)',
+        detail:'A physics-informed surrogate for steady-state organ thermal load (residual of ∇·(k∇T) − q minimised at collocation points). Surrogate, NOT a measured thermocouple readout.' }
+    ],
+    bounded_error:'Bounded error: the composed field is reported with an explicit relative-residual envelope (≤ 5% on the demo mesh); outside the modelled range it degrades to an honest “out-of-distribution — unquantified” state rather than extrapolating.',
+    never:'NEVER a locked theorem · NEVER counted in the locked-8 · NEVER claimed as a measurement.',
+
+    /* -------------------------------------------------------------------
+       LTC-derived state-dependent breathing overlay (ADDITIVE 2026-07-03).
+       Own-code reimplementation of the *pattern* from Liquid Time-Constant
+       Networks (Hasani, Lechner, Amini, Rus, Grosu; arXiv:2006.04439;
+       Apache-2.0). We reimplement ONLY the bounded first-order state-
+       dependent dynamics form — a "liquid" effective time-constant
+       tau_eff = 1/(1/tau + g), where a per-organ drift/anomaly signal g in
+       (0,1) shortens tau (organ breathes faster / reacts sooner) and a calm
+       organ lengthens it toward tau_base. This is a VIZ / modelling upgrade:
+       a rendered breathing rate, NOT a measurement and NOT a theorem. It is
+       NEVER folded into the locked-8 and NEVER relabels Λ.
+       ------------------------------------------------------------------- */
+    ltc_timescale:{
+      label:'LTC-derived · advisory · experimental',
+      citation:'pattern from Liquid Time-Constant Networks (arXiv:2006.04439, Apache-2.0); own-code reimplementation, no source vendored',
+      headline:'state-dependent organ breathing rate — liquid time-constant',
+      honest:'ADVISORY / experimental viz overlay. Each organ renders a breathing rate whose effective time-constant is state-dependent: a drifting / anomalous organ shortens tau (breathes faster), a calm organ lengthens tau toward its base. This is a MODELLED render, NOT a measured cadence and NOT a locked theorem; it is NEVER counted in the locked-8 and NEVER moves Λ off Conjecture 1.',
+      model:'tau_eff = 1 / (1/tau + g), with the fixed bounded gate g = sigmoid(drive) in (0,1) and tau clamped to [tau_min, tau_max]. Bounded by construction: tau_eff stays in (0, tau] so the render can never hyperventilate or freeze.',
+      tau_min:0.001,
+      tau_max:1000,
+      tau_units:'seconds (render cadence; advisory)',
+      drive:'The per-organ drive is the organ’s own honest liveness/drift signal where a live probe answers, and an explicit SAMPLE constant where none exists yet. A DOWN or unreachable probe reads as HIGH drift (organ breathes fast) — never a fabricated calm.',
+      organs:[
+        { organ_key:'willay', organ:'WILLAY / conscience', tau_base:8.0,
+          stress_source:'live', probe:V5_ENDPOINTS.willay,
+          detail:'Refusal-classifier surface. Drive = observed classifier activity / reachability from the live probe; a spike in refusals shortens tau (breathes faster). Unreachable ⇒ HIGH drift, not a fabricated calm.' },
+        { organ_key:'sovereign_mesh', organ:'SOVEREIGN MESH / circulatory', tau_base:6.0,
+          stress_source:'live', probe:V5_ENDPOINTS.mesh,
+          detail:'Per-node up/down from /govern/health. Drive rises as nodes read DOWN; a degraded mesh shortens tau. Never a fabricated green light — a silent mesh reads as HIGH drift.' },
+        { organ_key:'yawar', organ:'CIRCULATORY / receipt bus', tau_base:5.0,
+          stress_source:'live', probe:V5_ENDPOINTS.ledger,
+          detail:'Receipt hash-chain health. Drive = chain-head staleness / emit-rate anomaly from the live ledger probe; a stalled chain shortens tau.' },
+        { organ_key:'samay', organ:'RESPIRATORY / soak-loop breath', tau_base:12.0,
+          stress_source:'sample', sample_drive:0.35,
+          detail:'Soak-loop breath already breathes on wasted-energy windows; the LTC overlay adds an advisory state-dependent cadence. No dedicated live drift probe yet ⇒ honest SAMPLE drive, not fabricated telemetry.' },
+        { organ_key:'yuyay', organ:'HEART / gate', tau_base:4.0,
+          stress_source:'sample', sample_drive:0.25,
+          detail:'Gate cadence. Λ stays ADVISORY / Conjecture 1 — this overlay renders a breathing rate only and NEVER upgrades the heart-gate to a theorem. No live per-decision drift feed here yet ⇒ honest SAMPLE drive.' },
+        { organ_key:'amaru', organ:'BRAIN / cortex', tau_base:10.0,
+          stress_source:'sample', sample_drive:0.20,
+          detail:'Read-only reasoning cortex. No live drift probe ⇒ honest SAMPLE drive; the cortex breathes slowly (long tau) unless a future telemetry feed raises its drive.' }
+      ],
+      bounded:'Bounded by construction: g in (0,1) and tau in [tau_min, tau_max] ⇒ tau_eff in (0, tau]. The render is a contraction toward the observed drive — it cannot blow up.',
+      never:'NEVER a measurement · NEVER a locked theorem · NEVER counted in the locked-8 · NEVER relabels Λ off Conjecture 1 · a DOWN probe reads as high drift, never a fabricated calm.'
+    }
+  };
+
+  /* =====================================================================
+     v5 — GPU-SOVEREIGN STACK (SUBSTRATE) overlay (additive, honest)
+     The VERTICAL compute anatomy that complements the horizontal Sovereign
+     Mesh organ: owned GPU fabric → runtime → mesh / router → open-weight
+     model → native governance → buyer-verifiable receipts. Framed against
+     how the leaders present sovereign compute (chip → cloud → model), made
+     our own. Every layer carries an HONEST posture chip; live layers read
+     /govern/health and degrade to DOWN when unreachable — never a fabricated
+     green light. Adds NOTHING to the locked-8 and never relabels Λ.
+     ===================================================================== */
+  const STACK_LAYER = {
+    headline:'GPU-Sovereign Stack — the vertical substrate anatomy',
+    thesis:'Compute IS sovereignty: the organism runs on a ground GPU fabric we own and govern — not rented from a hyperscaler. The leaders present this as a chip → cloud → model cake; we make it our own by promoting governance and buyer-verifiable receipts to first-class layers and labelling every layer honestly.',
+    live_source:V5_ENDPOINTS.mesh,
+    layers:[
+      { tier:'L0', name:'Metal & energy — owned GPU fabric', posture:'REAL', chip:'live',
+        leaders:'Hyperscalers frame Layer-0 (power, PUE, cooling) as the binding constraint; sovereign clouds argue that sovereign AI cannot be built on rented compute.',
+        szl:'A real ground fabric operates today — an RTX-class tower anchor plus nodes, on the metal, with no hyperscaler tenancy. Node liveness is read live from /govern/health.',
+        honest:'Energy / joules are SAMPLE — UNAVAILABLE until a live NVML meter answers. Never a fabricated wattage.' },
+      { tier:'L1', name:'Runtime — open-weight inference engine', posture:'LIVE', chip:'live', live_key:'engine',
+        leaders:'The runtime (KV-cache, continuous batching, paged attention, tensor / pipeline parallelism) is where the neoclouds compete on tokens per second.',
+        szl:'Open-weight engines served on our own metal; engine count and tier read live. No closed-API dependency sits in the hot path.',
+        honest:'A node that does not answer reads DOWN — never a fabricated green light.' },
+      { tier:'L2', name:'Sovereign mesh — scheduler / router', posture:'LIVE', chip:'live', live_key:'mesh',
+        leaders:'Vendors sell a fused multi-GPU address space; sovereign meshes today are smart routers across independent nodes.',
+        szl:'Per-node F11 Ayni reciprocity (LOCKED) balances the mesh tit-for-tat. Open the Sovereign Mesh organ for live per-node up / DOWN.',
+        honest:'VRAM-fusion across nodes is ROADMAP — today the mesh is a scheduler / router, not a fused address space.' },
+      { tier:'L3', name:'Model — open weights, disclosed', posture:'PARTIAL', chip:'partial',
+        leaders:'NVIDIA packages models as NIM microservices; the model layer is weights + quantization + format + adapters.',
+        szl:'Open-weight only — engine identity and tier disclosed via /govern/health. The full model card (eval suite) is PARTIAL, not yet complete.',
+        honest:'Open-weight and disclosed — no opaque closed model is dressed up as ours.' },
+      { tier:'L4', name:'Governance — native, not bolted on', posture:'LOCKED', chip:'locked',
+        leaders:'A governed inference stack wraps every layer with access control, guardrails and audit logs — usually added after the fact.',
+        szl:'Governance is the HEART, not a wrapper: the YUYAY 13-axis conjunctive gate (deny-by-default) plus the WILLAY conscience adjudicate every inference before it runs; trust ceiling 0.97. Λ = Conjecture 1 — advisory, never a theorem.',
+        honest:'Trust is never 100% and no AGI is claimed. The gate is advisory-honest, not an infallible oracle.' },
+      { tier:'L5', name:'Verifiable compute — the frontier', posture:'PARTIAL', chip:'partial', receipt_key:'ledger',
+        leaders:'The 2026 frontier is proving a result was produced correctly without trusting the operator — TEE attestation (H100 / H200 confidential computing), ZK proofs, or signed receipts.',
+        szl:'Every governed decision emits a DSSE ECDSA-P256 receipt on an append-only hash-chain — verifiable OFFLINE in your browser, right here, no trust in us required. Hardware TEE / remote attestation of the GPU node is ROADMAP.',
+        honest:'Receipts are LIVE and buyer-verifiable now; on-metal TEE attestation is ROADMAP — labelled, not fabricated.' }
+    ],
+    frontier:'Where we push the frontier: most stacks bolt governance and audit on top of rented compute. We invert it — own the metal, make governance the beating heart, and make every output buyer-verifiable at the edge. Sovereignty you can check, not take on faith.',
+    never:'NEVER a fabricated green light · energy NEVER fabricated (SAMPLE until NVML) · VRAM-fusion and TEE attestation honestly ROADMAP · the locked set stays exactly 8 · Λ never a theorem.'
+  };
+
+  root.SZL_ANATOMY = { KERNEL, MATURITY, FORMULAS, ORGANS, SYSTEMS, BODIES, SKELETON_REPOS, PUTNAM_2025,
+                       QBIO, QBIO_LEADERS, QBIO_SOURCES, QBIO_THEOREMS,
+                       V5_ENDPOINTS, LEAN_MAP, ASSURANCE_MAP, PHYSICS_OVERLAY, STACK_LAYER };
+})(window);

docs/LIVING_ANATOMY_SECOND_BRAIN.md

@@ -0,0 +1,83 @@
+# Living Anatomy + YACHAY Second Brain
+
+## Production contract
+
+`betterwithage/anatomy` is a **KEEP / public / running** Hugging Face flagship. GitHub
+`szl-holdings/anatomy` is the runtime source of truth. The Space is a deployment
+mirror, not an independent source tree.
+
+The Docker entry point is `living_runtime.py`. It extends the existing hardened
+`server.py` in-process and preserves every static, evidence, receipt, organ-integrity,
+and security-header route. The extension adds a read-only YACHAY Brain organ:
+
+| Interface | Purpose |
+|---|---|
+| `GET /api/anatomy/v1/living-health` | Combined Anatomy + Brain readiness |
+| `GET /api/anatomy/v1/brain/health` | Snapshot integrity, source SHA, counts, authority |
+| `GET /api/anatomy/v1/brain/manifest` | Machine-readable source and interface contract |
+| `GET/POST /api/anatomy/v1/brain/search` | BM25-like public-handle retrieval |
+| `GET/POST /api/anatomy/v1/brain/context` | Model-safe handles plus evidence pointers |
+
+## Source binding
+
+`scripts/materialize_second_brain.py` resolves the exact protected-main revision of
+`szl-holdings/szl-second-brain`, downloads only:
+
+- `data/manifest.json`
+- `data/brain-corpus.public.jsonl`
+
+It validates:
+
+1. exactly 575 public chunks;
+2. the declared source histogram;
+3. every row's SHA-256;
+4. `secretScan: PASS`;
+5. unique public node IDs.
+
+The operator writes `.runtime/second-brain/source.json` with the exact Git SHA,
+manifest digest, corpus digest, count, and authority constraints. The HF sync workflow
+bundles that immutable snapshot and records the dependency in
+`hf-deploy-manifest.json`.
+
+## Non-negotiable boundary
+
+The public Space returns **handles only**. It does not expose corpus text through the
+API, load the owner's private 9,464-node graph, train weights, execute tools, or hold
+write authority. Lexical ranking is relevance, never correctness. Lambda remains
+Conjecture 1.
+
+The richer product-side living-brain loop in `szl-holdings/a11oy` remains a separate
+governed execution surface. The public HF Anatomy is its inspectable, read-only
+anatomical instrument—not a duplicate mutation authority.
+
+## Reproduce locally
+
+```bash
+python scripts/materialize_second_brain.py --output .runtime/second-brain
+python -m unittest discover -s tests -v
+python living_runtime.py
+```
+
+Then inspect:
+
+```text
+http://127.0.0.1:7860/api/anatomy/v1/living-health
+http://127.0.0.1:7860/api/anatomy/v1/brain/health
+http://127.0.0.1:7860/api/anatomy/v1/brain/search?q=governed%20receipts&k=6
+```
+
+## Lifecycle
+
+`.github/workflows/hf-sync.yml` runs on protected-main changes, manual dispatch, and
+a six-hour reconciliation cadence. It:
+
+1. validates the exact Second Brain projection;
+2. refuses a stale GitHub source revision;
+3. makes `betterwithage/anatomy` public;
+4. restarts paused, sleeping, stopped, or failed runtime states;
+5. avoids a rebuild when both source revisions are already deployed;
+6. verifies the live Anatomy, Brain, version, evidence, source, and manifest contracts.
+
+A separate estate keep policy in `szl-holdings/a11oy` must include
+`betterwithage/anatomy`; otherwise the fleet consolidator will correctly treat it as a
+fold. That policy is part of the same coordinated repair.

docs/holographic-space-v2.md

@@ -0,0 +1,16 @@
+# Anatomy Holo-Constellation v2
+
+The Anatomy Space keeps its existing interactive organ map, evidence APIs, receipt verifier, and fail-closed runtime semantics. Holo-Constellation v2 adds a local visual instrument and shared estate navigation without changing those product contracts.
+
+## Runtime-integrity boundary
+
+Both new browser assets are included in `server.ARTIFACT_PATHS`:
+
+- `szl-holo-v2.css`
+- `szl-holo-v2.js`
+
+They therefore participate in the Anatomy runtime manifest and structural receipt rather than being served as untracked presentation files.
+
+## Accessibility boundary
+
+The shared layer provides keyboard focus, 44-pixel controls, reduced-motion behavior, increased-contrast behavior, forced-color behavior, responsive navigation, and print handling. Decorative animation is presentation only and is not reported as telemetry or operational evidence.

frontier_anatomy.js

@@ -0,0 +1,113 @@
+/* SZL Living Anatomy — Evidence Bay.
+ * Clean-room, SZL-native industrial evidence surface. Zero CDN and read-only.
+ * Transport, evidence, verification, and authority remain separate dimensions.
+ */
+(function (root) {
+  'use strict';
+  var API = '/api/anatomy/v1';
+  var state = { manifest:null, capabilities:null, evidence:null, tab:'overview', busy:false };
+  var previousFocus = null;
+
+  function esc(value) {
+    return String(value == null ? '' : value).replace(/[&<>"']/g, function (c) {
+      return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c];
+    });
+  }
+  function fetchJSON(url, opts, timeout) {
+    var ctl = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    var timer = ctl ? setTimeout(function(){ ctl.abort(); }, timeout || 10000) : null;
+    opts = opts || {}; opts.cache = 'no-store'; if (ctl) opts.signal = ctl.signal;
+    return fetch(url, opts).then(function (r) {
+      if (timer) clearTimeout(timer);
+      return r.json().then(function (data) { return {ok:r.ok,status:r.status,data:data}; });
+    }).catch(function (error) {
+      if (timer) clearTimeout(timer);
+      return {ok:false,status:0,data:null,error:String(error && error.message || error)};
+    });
+  }
+
+  var css = [
+    '#fa-launch{position:fixed;z-index:197;right:18px;top:50%;transform:translateY(-50%);width:132px;text-align:left;background:rgba(7,11,16,.94);color:#dce8ea;border:1px solid rgba(101,169,174,.38);border-right:2px solid #63d4cf;box-shadow:0 18px 50px rgba(0,0,0,.42);padding:10px 12px;cursor:pointer;font-family:var(--font-m,monospace);text-transform:uppercase;letter-spacing:.10em;backdrop-filter:blur(14px)}',
+    '#fa-launch:hover,#fa-launch:focus-visible{border-color:#63d4cf;color:#fff;outline:none;box-shadow:0 0 0 2px rgba(99,212,207,.18),0 18px 50px rgba(0,0,0,.55)}',
+    '#fa-launch .fa-l1{display:flex;align-items:center;gap:8px;font-size:9px;font-weight:800}#fa-launch .fa-l2{display:block;margin-top:5px;color:#829195;font-size:8px;letter-spacing:.06em;text-transform:none}',
+    '.fa-signal{width:7px;height:7px;border-radius:1px;background:#63d4cf;box-shadow:0 0 12px rgba(99,212,207,.7)}',
+    '#fa-scrim{position:fixed;z-index:198;inset:0;background:rgba(0,0,0,.52);opacity:0;pointer-events:none;transition:opacity .2s ease}#fa-scrim.open{opacity:1;pointer-events:auto}',
+    '#fa-panel{position:fixed;z-index:199;right:0;top:0;height:100%;width:min(570px,100vw);display:flex;flex-direction:column;background:linear-gradient(180deg,#0b1015 0%,#070b0f 100%);color:#dce5e6;border-left:1px solid #273237;box-shadow:-30px 0 90px rgba(0,0,0,.62);transform:translateX(102%);transition:transform .24s cubic-bezier(.2,.8,.2,1);font-family:var(--font-d,system-ui);pointer-events:auto}#fa-panel.open{transform:translateX(0)}',
+    'body.fa-open #ux-tabbar,body.fa-open #ux-more-menu,body.fa-open #dissect-fab{opacity:0!important;pointer-events:none!important}',
+    '.fa-top{padding:18px 20px 14px;border-bottom:1px solid #273237;background:#0d1318}.fa-kicker{display:flex;align-items:center;gap:8px;color:#78d9d4;font:800 9px/1 var(--font-m,monospace);letter-spacing:.20em;text-transform:uppercase}.fa-kicker:before{content:"";width:18px;height:1px;background:#78d9d4}',
+    '.fa-title-row{display:flex;justify-content:space-between;align-items:flex-start;gap:16px;margin-top:10px}.fa-title{margin:0;font-size:25px;line-height:1.05;font-weight:620;letter-spacing:-.025em;color:#f2f7f7}.fa-subtitle{margin:7px 0 0;color:#8e9da0;font:11px/1.5 var(--font-m,monospace);max-width:46ch}',
+    '.fa-close{flex:0 0 auto;width:34px;height:34px;color:#aebbbd;background:#11191e;border:1px solid #334047;cursor:pointer;font-size:18px}.fa-close:hover,.fa-close:focus-visible{color:#fff;border-color:#78d9d4;outline:none}',
+    '.fa-rail{display:grid;grid-template-columns:repeat(4,1fr);border-bottom:1px solid #273237;background:#080d11}.fa-dim{padding:10px 11px;border-right:1px solid #20292e;min-width:0}.fa-dim:last-child{border-right:0}.fa-dim-label{display:block;color:#647277;font:8px/1.2 var(--font-m,monospace);letter-spacing:.12em;text-transform:uppercase}.fa-dim-value{display:block;margin-top:5px;color:#c7d2d4;font:800 9px/1.2 var(--font-m,monospace);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}',
+    '.fa-dim-value.live,.fa-dim-value.computed,.fa-dim-value.reachable,.fa-dim-value.available{color:#78d9d4}.fa-dim-value.mixed,.fa-dim-value.structural_only,.fa-dim-value.snapshot,.fa-dim-value.modeled{color:#e1bd71}.fa-dim-value.unavailable,.fa-dim-value.failed,.fa-dim-value.unreachable,.fa-dim-value.missing{color:#e37d8f}',
+    '.fa-tabs{display:flex;padding:0 20px;border-bottom:1px solid #273237;background:#0b1015;overflow:auto}.fa-tab{appearance:none;border:0;border-bottom:2px solid transparent;background:transparent;color:#718086;padding:12px 11px 10px;font:800 9px/1 var(--font-m,monospace);letter-spacing:.12em;text-transform:uppercase;cursor:pointer;white-space:nowrap}.fa-tab:hover{color:#cad5d7}.fa-tab.active{color:#78d9d4;border-bottom-color:#78d9d4}.fa-tab:focus-visible{outline:1px solid #78d9d4;outline-offset:-3px}',
+    '.fa-body{flex:1;overflow:auto;padding:20px 20px 90px;scrollbar-color:#334047 #0b1015}.fa-section{margin:0 0 24px}.fa-section-head{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:0 0 11px}.fa-section h3{margin:0;color:#aebbbd;font:800 9px/1.2 var(--font-m,monospace);letter-spacing:.15em;text-transform:uppercase}.fa-rule{height:1px;flex:1;background:#273237}',
+    '.fa-lede{margin:0;color:#d6dfe0;font-size:15px;line-height:1.55;letter-spacing:-.005em}.fa-callout{border-left:2px solid #78d9d4;background:#0d1519;padding:12px 13px;margin-top:14px;color:#9daaad;font:11px/1.55 var(--font-m,monospace)}',
+    '.fa-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}.fa-stat{background:#0d1318;border:1px solid #273237;padding:12px;min-height:88px}.fa-stat .k{color:#6f7e82;font:8px/1.2 var(--font-m,monospace);letter-spacing:.12em;text-transform:uppercase}.fa-stat .v{margin-top:9px;color:#edf3f3;font:800 12px/1.2 var(--font-m,monospace)}.fa-stat p{margin:8px 0 0;color:#79888c;font-size:10px;line-height:1.4}',
+    '.fa-actions{display:flex;flex-wrap:wrap;gap:7px;margin-top:14px}.fa-btn,.fa-link{display:inline-flex;align-items:center;justify-content:center;min-height:34px;padding:0 11px;border:1px solid #35444a;background:#10181d;color:#bdc9cb;text-decoration:none;cursor:pointer;font:800 9px/1 var(--font-m,monospace);letter-spacing:.08em;text-transform:uppercase}.fa-btn.primary{border-color:#2b8c8a;background:#12302f;color:#9ff1ec}.fa-btn:hover,.fa-link:hover,.fa-btn:focus-visible,.fa-link:focus-visible{border-color:#78d9d4;color:#fff;outline:none}.fa-btn:disabled{opacity:.45;cursor:wait}',
+    '.fa-cap{border:1px solid #273237;background:#0b1115;margin:0 0 9px}.fa-cap summary{list-style:none;display:grid;grid-template-columns:30px 1fr auto;align-items:center;gap:10px;padding:12px 13px;cursor:pointer}.fa-cap summary::-webkit-details-marker{display:none}.fa-cap summary:hover{background:#0f171c}.fa-num{color:#536267;font:800 9px/1 var(--font-m,monospace)}.fa-cap-name{color:#e4ebec;font-size:13px;font-weight:650}.fa-cap-id{display:block;margin-top:3px;color:#617075;font:8px/1.2 var(--font-m,monospace)}',
+    '.fa-badge{display:inline-block;border:1px solid #3c4a4f;color:#8e9c9f;padding:3px 6px;font:800 8px/1 var(--font-m,monospace);letter-spacing:.06em;text-transform:uppercase}.fa-badge.live,.fa-badge.computed,.fa-badge.available,.fa-badge.pass{border-color:#286d6b;color:#78d9d4;background:rgba(40,109,107,.13)}.fa-badge.snapshot,.fa-badge.mixed,.fa-badge.modeled,.fa-badge.structural-only,.fa-badge.structural_only,.fa-badge.unavailable,.fa-badge.read_only{border-color:#685937;color:#e1bd71;background:rgba(104,89,55,.12)}.fa-badge.fail,.fa-badge.failed,.fa-badge.missing,.fa-badge.unreachable{border-color:#663640;color:#e37d8f;background:rgba(102,54,64,.12)}',
+    '.fa-cap-body{border-top:1px solid #273237;padding:13px}.fa-field{display:grid;grid-template-columns:86px 1fr;gap:12px;padding:8px 0;border-bottom:1px solid #1e272b}.fa-field:last-child{border-bottom:0}.fa-field dt{color:#657378;font:800 8px/1.4 var(--font-m,monospace);letter-spacing:.12em;text-transform:uppercase}.fa-field dd{margin:0;color:#aebabc;font-size:11px;line-height:1.52;min-width:0}.fa-field ul,.fa-field ol{margin:0;padding-left:17px}.fa-field li+li{margin-top:5px}',
+    '.fa-code{display:block;margin-top:5px;padding:8px;background:#070b0e;border:1px solid #202b30;color:#8ed6d2;font:9px/1.5 var(--font-m,monospace);word-break:break-all}.fa-refs{display:flex;flex-wrap:wrap;gap:5px;margin-top:7px}.fa-ref{color:#8ec6c4;text-decoration:none;border-bottom:1px solid #31504f;font:9px/1.4 var(--font-m,monospace)}.fa-ref:hover{color:#fff;border-color:#78d9d4}',
+    '.fa-dep{display:grid;grid-template-columns:1fr auto;gap:10px;padding:12px 0;border-bottom:1px solid #20292e}.fa-dep:last-child{border-bottom:0}.fa-dep-name{color:#d8e1e2;font-size:12px;font-weight:650}.fa-dep-purpose{display:block;margin-top:4px;color:#718084;font-size:10px;line-height:1.4}.fa-dep-meta{display:block;margin-top:5px;color:#4f6065;font:8px/1.3 var(--font-m,monospace);word-break:break-all}.fa-dep-state{text-align:right;min-width:88px}.fa-http{display:block;margin-top:5px;color:#66757a;font:8px/1 var(--font-m,monospace)}',
+    '.fa-output{margin-top:12px;background:#070b0e;border:1px solid #273237;padding:11px;color:#9caaad;font:10px/1.55 var(--font-m,monospace);word-break:break-word}.fa-output.good{border-color:#286d6b;color:#9be2de}.fa-output.bad{border-color:#663640;color:#e3a0ab}',
+    '.fa-endpoint{padding:12px 0;border-bottom:1px solid #20292e}.fa-endpoint:last-child{border-bottom:0}.fa-endpoint a{color:#c8d5d6;text-decoration:none;font:700 10px/1.4 var(--font-m,monospace)}.fa-endpoint a:hover{color:#78d9d4}.fa-endpoint p{margin:5px 0 0;color:#6f7d81;font-size:10px;line-height:1.45}',
+    '.fa-loading{padding:28px 0;color:#6e7b7f;font:10px/1.5 var(--font-m,monospace);text-transform:uppercase;letter-spacing:.12em}.fa-loading:before{content:"";display:inline-block;width:7px;height:7px;margin-right:9px;background:#e1bd71;animation:fa-pulse .9s ease-in-out infinite}@keyframes fa-pulse{50%{opacity:.25}}',
+    '@media(max-width:760px){#fa-launch{right:8px;top:auto;bottom:76px;transform:none;width:auto;padding:9px 11px}#fa-launch .fa-l2{display:none}#fa-panel{width:100vw}.fa-grid{grid-template-columns:1fr}.fa-body{padding:16px 15px 100px}.fa-top{padding:16px 15px 13px}.fa-tabs{padding:0 10px}.fa-rail{grid-template-columns:repeat(2,1fr)}.fa-dim:nth-child(2){border-right:0}.fa-dim:nth-child(-n+2){border-bottom:1px solid #20292e}.fa-field{grid-template-columns:72px 1fr}}',
+    '@media(prefers-reduced-motion:reduce){#fa-panel,#fa-scrim{transition:none}.fa-loading:before{animation:none}}'
+  ].join('');
+
+  function injectStyle(){ if(document.getElementById('fa-style'))return; var s=document.createElement('style');s.id='fa-style';s.textContent=css;document.head.appendChild(s); }
+  function badge(value){var label=String(value||'UNKNOWN');return '<span class="fa-badge '+esc(label.toLowerCase())+'">'+esc(label.replace(/_/g,'-'))+'</span>';}
+  function dim(label,value){var v=String(value||'UNKNOWN');return '<div class="fa-dim"><span class="fa-dim-label">'+esc(label)+'</span><span class="fa-dim-value '+esc(v.toLowerCase())+'">'+esc(v.replace(/_/g,'-'))+'</span></div>';}
+  function list(values,ordered){if(!Array.isArray(values)||!values.length)return '<span>None declared.</span>';var tag=ordered?'ol':'ul';return '<'+tag+'>'+values.map(function(v){return '<li>'+esc(v)+'</li>';}).join('')+'</'+tag+'>';}
+  function links(values){if(!Array.isArray(values)||!values.length)return '';return '<div class="fa-refs">'+values.map(function(url,i){return '<a class="fa-ref" href="'+esc(url)+'" target="_blank" rel="noopener">source '+(i+1)+' ↗</a>';}).join('')+'</div>';}
+  function sectionHead(title){return '<div class="fa-section-head"><h3>'+esc(title)+'</h3><span class="fa-rule"></span></div>';}
+
+  function updateRail(){
+    var d=state.manifest&&state.manifest.state_dimensions||{};
+    if(state.evidence)d=Object.assign({},d,{evidence_state:state.evidence.evidence_state,verification_state:state.evidence.verification_state==='AVAILABLE'?'AVAILABLE':d.verification_state});
+    var rail=document.getElementById('fa-rail');if(rail)rail.innerHTML=dim('transport',d.transport_state)+dim('evidence',d.evidence_state)+dim('verification',d.verification_state)+dim('authority',d.authority_state);
+    var sub=document.querySelector('#fa-launch .fa-l2');if(sub)sub.textContent=(d.evidence_state||'loading')+' evidence · read-only';
+  }
+  function overviewHTML(){
+    var m=state.manifest||{},d=m.state_dimensions||{};
+    return '<section class="fa-section">'+sectionHead('Mission contract')+'<p class="fa-lede">'+esc(m.purpose||'Read-only spatial evidence map of the governed-agent substrate.')+'</p><div class="fa-callout">One green light is not enough. Transport, evidence, verification, and authority are independent dimensions; this console refuses to collapse them into a single “healthy” claim.</div></section>'+
+      '<section class="fa-section">'+sectionHead('Current posture')+'<div class="fa-grid"><div class="fa-stat"><div class="k">Transport</div><div class="v">'+esc(d.transport_state||'—')+'</div><p>Can this Space answer a request?</p></div><div class="fa-stat"><div class="k">Evidence</div><div class="v">'+esc(state.evidence&&state.evidence.evidence_state||d.evidence_state||'—')+'</div><p>Live, computed, snapshot, modeled, or unavailable?</p></div><div class="fa-stat"><div class="k">Verification</div><div class="v">'+esc(d.verification_state||'—')+'</div><p>The local receipt is unsigned and structural-only.</p></div><div class="fa-stat"><div class="k">Authority</div><div class="v">'+esc(d.authority_state||'—')+'</div><p>Anatomy reads and explains; it cannot actuate.</p></div></div><div class="fa-actions"><button class="fa-btn primary" id="fa-verify-bundle">Verify deployed bundle</button><button class="fa-btn" id="fa-refresh">Refresh live evidence</button><a class="fa-link" href="/.well-known/szl-source.json" target="_blank" rel="noopener">Source attestation ↗</a></div><div id="fa-overview-output" aria-live="polite"></div></section>'+
+      '<section class="fa-section">'+sectionHead('Honest boundary')+list(m.limits||[],false)+'</section>';
+  }
+  function capabilitiesHTML(){
+    var rows=state.capabilities&&state.capabilities.capabilities||[];if(!rows.length)return '<div class="fa-loading">Capability contract unavailable</div>';
+    return '<section class="fa-section">'+sectionHead('Five-part capability shell')+'<p class="fa-lede" style="font-size:12px">Every surface declares Purpose, Try, Evidence, Limits, and Reproduce before it earns a place in the body.</p></section>'+rows.map(function(cap,i){
+      var ev=cap.evidence||{},t=cap.try||{},r=cap.reproduce||{};
+      return '<details class="fa-cap"'+(i===0?' open':'')+'><summary><span class="fa-num">'+String(i+1).padStart(2,'0')+'</span><span class="fa-cap-name">'+esc(cap.name)+'<span class="fa-cap-id">'+esc(cap.id)+'</span></span>'+badge(ev.state)+'</summary><div class="fa-cap-body"><dl><div class="fa-field"><dt>Purpose</dt><dd>'+esc(cap.purpose)+'</dd></div><div class="fa-field"><dt>Try</dt><dd>'+esc(t.action||'')+'<code class="fa-code">'+esc((t.method||'')+' '+(t.path||''))+'</code></dd></div><div class="fa-field"><dt>Evidence</dt><dd>'+badge(ev.state)+' '+esc(ev.basis||'')+'</dd></div><div class="fa-field"><dt>Limits</dt><dd>'+list(cap.limits,false)+'</dd></div><div class="fa-field"><dt>Reproduce</dt><dd>'+list(r.steps,true)+'</dd></div><div class="fa-field"><dt>Authority</dt><dd>'+badge(cap.authority_state)+'</dd></div><div class="fa-field"><dt>Formula refs</dt><dd>'+(cap.formula_refs&&cap.formula_refs.length?esc(cap.formula_refs.join(' · ')):'None — visual capability only.')+links(cap.provenance)+'</dd></div></dl></div></details>';
+    }).join('');
+  }
+  function evidenceHTML(){
+    if(!state.evidence)return '<div class="fa-loading">Measuring declared dependencies</div>';var e=state.evidence;
+    return '<section class="fa-section">'+sectionHead('Measured dependency plane')+'<p class="fa-lede" style="font-size:12px">'+esc(e.scope)+'</p><div class="fa-callout">Observed '+esc(e.observed_at)+' · '+esc(e.summary&&e.summary.live)+'/'+esc(e.summary&&e.summary.total)+' declared contracts available.</div>'+(e.dependencies||[]).map(function(dep){return '<div class="fa-dep"><div><span class="fa-dep-name">'+esc(dep.id)+'</span><span class="fa-dep-purpose">'+esc(dep.purpose)+'</span><span class="fa-dep-meta">'+esc(dep.method+' '+dep.url)+'</span></div><div class="fa-dep-state">'+badge(dep.contract_state)+'<span class="fa-http">HTTP '+esc(dep.http_status==null?'—':dep.http_status)+'</span></div></div>';}).join('')+'<div class="fa-actions"><button class="fa-btn primary" id="fa-refresh">Re-probe now</button><a class="fa-link" href="https://huggingface.co/spaces/SZLHOLDINGS/governed-receipt-verifier" target="_blank" rel="noopener">Independent verifier ↗</a></div></section><section class="fa-section">'+sectionHead('Interpretation limits')+list(e.limits,false)+'</section>';
+  }
+  function reproduceHTML(){
+    var ep=state.manifest&&state.manifest.endpoints||{},desc={version:'Exact GitHub source and deployed Space revision.',evidence_index:'Release identity, structural bundle receipt, and dependency evidence index.',manifest:'Contract, vocabulary, doctrine boundary, and limits.',capabilities:'Purpose / Try / Evidence / Limits / Reproduce for each capability.',evidence:'Fresh server-side probes of declared upstream contracts.',receipt:'Deterministic SHA-256 receipt over the deployed artifact set.',verify_receipt:'POST a local anatomy receipt; structural integrity only.',source:'GitHub base, measured HF revision, artifact digest, and alignment state.'};
+    return '<section class="fa-section">'+sectionHead('Machine-readable contract')+Object.keys(ep).map(function(k){var p=ep[k];return '<div class="fa-endpoint"><a href="'+esc(p.replace('?refresh=1',''))+'" target="_blank" rel="noopener">'+esc(p)+' ↗</a><p>'+esc(desc[k]||'')+'</p></div>';}).join('')+'</section><section class="fa-section">'+sectionHead('Receipt replay')+'<p class="fa-lede" style="font-size:12px">Generate the receipt, then submit the unchanged object to the local verifier. A byte or digest mutation must produce FAIL.</p><code class="fa-code">GET /api/anatomy/v1/receipt<br>POST /api/anatomy/v1/verify/receipt</code><div class="fa-actions"><button class="fa-btn primary" id="fa-verify-bundle">Run replay now</button><a class="fa-link" href="https://github.com/szl-holdings/anatomy" target="_blank" rel="noopener">GitHub source ↗</a></div><div id="fa-overview-output" aria-live="polite"></div></section>';
+  }
+  function bodyHTML(){if(!state.manifest||!state.capabilities)return '<div class="fa-loading">Loading anatomy contract</div>';if(state.tab==='capabilities')return capabilitiesHTML();if(state.tab==='evidence')return evidenceHTML();if(state.tab==='reproduce')return reproduceHTML();return overviewHTML();}
+  function render(){updateRail();var body=document.getElementById('fa-body');if(body)body.innerHTML=bodyHTML();document.querySelectorAll('.fa-tab').forEach(function(b){b.classList.toggle('active',b.getAttribute('data-tab')===state.tab);b.setAttribute('aria-selected',b.classList.contains('active')?'true':'false');});wireBodyActions();}
+  function setOutput(html,kind){var out=document.getElementById('fa-overview-output');if(out)out.innerHTML='<div class="fa-output '+esc(kind||'')+'">'+html+'</div>';}
+  function verifyBundle(){
+    if(state.busy)return;state.busy=true;setOutput('Hashing the deployed artifact set and replaying the receipt…','');
+    fetchJSON(API+'/receipt').then(function(res){if(!res.ok)return res;return fetchJSON(API+'/verify/receipt',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(res.data)});}).then(function(res){state.busy=false;if(!res||!res.ok||!res.data){setOutput('Verifier unavailable. No verdict was inferred.','bad');return;}var checks=(res.data.checks||[]).map(function(c){return esc(c.name)+'='+esc(c.status);}).join(' · ');setOutput('<strong>'+esc(res.data.verdict)+'</strong><br>'+checks+'<br><span style="color:#66777a">'+esc(res.data.limits)+'</span>',res.data.verdict==='FAIL'?'bad':'good');});
+  }
+  function loadEvidence(force){fetchJSON(API+'/evidence'+(force?'?refresh=1':''),{},16000).then(function(res){state.evidence=res.ok?res.data:{evidence_state:'UNAVAILABLE',verification_state:'UNAVAILABLE',scope:'Evidence endpoint unavailable.',summary:{live:0,total:0},dependencies:[],limits:['No dependency state was inferred.']};render();});}
+  function wireBodyActions(){document.querySelectorAll('#fa-refresh').forEach(function(b){b.addEventListener('click',function(){b.disabled=true;if(state.tab==='evidence'){state.evidence=null;render();}loadEvidence(true);});});document.querySelectorAll('#fa-verify-bundle').forEach(function(b){b.addEventListener('click',verifyBundle);});}
+  function open(){previousFocus=document.activeElement;document.body.classList.add('fa-open');document.getElementById('fa-panel').classList.add('open');document.getElementById('fa-panel').setAttribute('aria-hidden','false');document.getElementById('fa-scrim').classList.add('open');document.getElementById('fa-launch').setAttribute('aria-expanded','true');document.getElementById('fa-close').focus();}
+  function close(){document.body.classList.remove('fa-open');document.getElementById('fa-panel').classList.remove('open');document.getElementById('fa-panel').setAttribute('aria-hidden','true');document.getElementById('fa-scrim').classList.remove('open');document.getElementById('fa-launch').setAttribute('aria-expanded','false');if(previousFocus&&previousFocus.focus)previousFocus.focus();}
+  function mount(){
+    if(document.getElementById('fa-panel'))return;injectStyle();
+    var launch=document.createElement('button');launch.id='fa-launch';launch.type='button';launch.setAttribute('aria-controls','fa-panel');launch.setAttribute('aria-expanded','false');launch.innerHTML='<span class="fa-l1"><i class="fa-signal"></i>Evidence bay</span><span class="fa-l2">loading contract · read-only</span>';
+    var scrim=document.createElement('div');scrim.id='fa-scrim';var panel=document.createElement('aside');panel.id='fa-panel';panel.setAttribute('role','dialog');panel.setAttribute('aria-modal','false');panel.setAttribute('aria-hidden','true');panel.setAttribute('aria-label','Anatomy evidence bay');panel.innerHTML='<header class="fa-top"><div class="fa-kicker">Anatomy contract 1.0</div><div class="fa-title-row"><div><h2 class="fa-title">Evidence Bay</h2><p class="fa-subtitle">Purpose · Try · Evidence · Limits · Reproduce</p></div><button class="fa-close" id="fa-close" type="button" aria-label="Close evidence bay">×</button></div></header><div class="fa-rail" id="fa-rail">'+dim('transport','LOADING')+dim('evidence','LOADING')+dim('verification','LOADING')+dim('authority','READ_ONLY')+'</div><nav class="fa-tabs" role="tablist" aria-label="Evidence Bay sections"><button class="fa-tab active" role="tab" data-tab="overview">Overview</button><button class="fa-tab" role="tab" data-tab="capabilities">Capabilities</button><button class="fa-tab" role="tab" data-tab="evidence">Evidence</button><button class="fa-tab" role="tab" data-tab="reproduce">Reproduce</button></nav><main class="fa-body" id="fa-body"><div class="fa-loading">Loading anatomy contract</div></main>';
+    document.body.appendChild(launch);document.body.appendChild(scrim);document.body.appendChild(panel);launch.addEventListener('click',open);scrim.addEventListener('click',close);document.getElementById('fa-close').addEventListener('click',close);document.querySelectorAll('.fa-tab').forEach(function(b){b.addEventListener('click',function(){state.tab=b.getAttribute('data-tab');render();document.getElementById('fa-body').scrollTop=0;});});document.addEventListener('keydown',function(e){if(e.key==='Escape'&&panel.classList.contains('open'))close();});
+    Promise.all([fetchJSON(API+'/manifest'),fetchJSON(API+'/capabilities')]).then(function(results){if(results[0].ok)state.manifest=results[0].data;if(results[1].ok)state.capabilities=results[1].data;render();loadEvidence(false);});
+  }
+  root.SZL_ANATOMY_EVIDENCE_BAY={mount:mount,open:open,close:close,refresh:function(){loadEvidence(true);},verifyBundle:verifyBundle};
+  if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',mount);else mount();
+})(typeof window!=='undefined'?window:this);

hf-deploy-manifest.json

@@ -0,0 +1,24 @@
+{
+  "dependencies": {
+    "second_brain": {
+      "authority_state": "READ_ONLY",
+      "content_access": "HANDLES_ONLY",
+      "corpus_sha256": "387337acbd8fe443637102fe7ea75387fa4c3d9d746d8ab6e2d14d6c138aad8f",
+      "public_chunk_count": 575,
+      "source_repository": "szl-holdings/szl-second-brain",
+      "source_revision": "ff03b116a83f2b5302999ab4167d51e35aba3b5e"
+    }
+  },
+  "destination": {
+    "lifecycle": "PUBLIC_CREATIVE",
+    "mode": "creator-profile",
+    "repo_id": "betterwithage/anatomy",
+    "repo_type": "space",
+    "visibility": "public"
+  },
+  "schema": "szl.hf-deploy-manifest/v1",
+  "source_path": "",
+  "source_repository": "szl-holdings/anatomy",
+  "source_revision": "6e7f19a7b7597c618df52fffd5b1812d1e8a82c5",
+  "workflow_run_id": "33820819238"
+}

lib/szl_verify_widget.js

@@ -0,0 +1,214 @@
+/* ============================================================================
+ * SZL "ask the fabric" — verify-a-claim widget  (vendored, self-contained)
+ * ----------------------------------------------------------------------------
+ * 0 runtime CDN · system fonts only · AbortController · honest fallback.
+ * Calls the REAL a11oy verify endpoint and renders its REAL honest verdict.
+ *   POST {base}/api/a11oy/v1/verify/receipt   body = {envelope: <DSSE envelope>}
+ *   Public receipt URLs are fetched in the browser and submitted to that endpoint.
+ *
+ * Doctrine v11: this widget NEVER fabricates a verdict. It shows exactly what
+ * the server returns (verdict: VERIFIED | STRUCTURAL-ONLY | FAILED | UNRECOGNISED).
+ * "STRUCTURAL-ONLY" is shown as advisory, NOT green. Network/timeout/429 degrade
+ * to an honest "unreachable / rate-limited" state — never to a false green.
+ *
+ * Attribution (clean-room rebuild of permissive ideas — see dev7 report):
+ *   - Tool-call / receipt trace UI pattern inspired by smolagents (Apache-2.0,
+ *     huggingface/smolagents) and assistant-ui (MIT). Rebuilt SZL-native; no code copied.
+ *   - AbortController fetch contract reuses anatomy V8 (SZL own prior art).
+ * ==========================================================================*/
+(function (global) {
+  'use strict';
+
+  var DEFAULT_BASE = 'https://szlholdings-a11oy.hf.space';
+  var VERIFY_PATH  = '/api/a11oy/v1/verify/receipt';
+  var TIMEOUT_MS   = 12000;
+  var SAMPLE = {
+    payloadType: 'application/vnd.szl.receipt+json',
+    payload: 'eyJib2R5Ijp7ImNsYWltIjoic3psLXdpZGdldC1jb250cmFjdCIsIm9yZ2FuIjoicHVibGljLXZlcmlmaWVyLXdpZGdldCIsInZhbHVlIjoic2FtcGxlIn0sInBheWxvYWRfZGlnZXN0IjoiMzU0YWZlZDZlMWQyODVjNDgxZTg4OWFlZGQzZDA4ODA3YzhhYTc5MjkyM2IzMThhMTc0YjNiNTg1OWI2N2FhMSJ9',
+    signatures: []
+  };
+
+  function esc(s){ return String(s==null?'':s).replace(/[&<>"]/g,function(c){
+    return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]; }); }
+
+  /* honest fetch contract: AbortController + try/catch. NEVER throws. ----- */
+  function pull(url, opts, timeoutMs){
+    var ctl = (typeof AbortController!=='undefined') ? new AbortController() : null;
+    var to  = ctl ? setTimeout(function(){ try{ctl.abort();}catch(e){} }, timeoutMs||TIMEOUT_MS) : null;
+    opts = opts || {};
+    opts.signal = ctl ? ctl.signal : undefined;
+    opts.cache  = 'no-store';
+    opts.mode   = 'cors';
+    return fetch(url, opts).then(function(r){
+      if(to) clearTimeout(to);
+      var status = r.status;
+      return r.json().then(function(data){ return {ok:r.ok, status:status, data:data}; },
+                          function(){ return {ok:false, status:status, data:null}; });
+    }).catch(function(e){
+      if(to) clearTimeout(to);
+      var aborted = e && (e.name==='AbortError');
+      return {ok:false, status:0, data:null, err:String(e&&e.message||e), aborted:aborted};
+    });
+  }
+
+  /* map an HONEST verdict string -> {label, cls, advisory} ---------------- */
+  function verdictView(v){
+    var s = String(v||'').toUpperCase();
+    if(s==='PASS'||s==='VERIFIED') return {label:s, cls:'ok', advisory:false};
+    if(s==='PARTIAL'||s==='STRUCTURAL-ONLY'||s==='INCONCLUSIVE') return {label:s, cls:'warn', advisory:true};
+    if(s==='FAIL'||s==='FAILED'||s==='MISMATCH') return {label:'FAIL', cls:'fail', advisory:false};
+    if(s==='NO_INPUT'||s==='UNRECOGNISED') return {label:s, cls:'muted', advisory:false};
+    return {label: s||'—', cls:'muted', advisory:false};
+  }
+
+  function renderChecks(checks){
+    if(!Array.isArray(checks) || !checks.length) return '';
+    var rows = checks.map(function(c){
+      var st = String(c.status||'').toLowerCase();
+      var cls = (st==='pass'||st==='verified') ? 'ok' :
+        ((st==='fail'||st==='mismatch') ? 'fail' : (st==='unsigned-local' ? 'warn' : 'muted'));
+      return '<li class="szlv-chk"><span class="szlv-pill '+cls+'">'+esc(c.status||'?')+'</span>'+
+             '<code>'+esc(c.name||c.check||'check')+'</code>'+
+             (c.detail ? '<span class="szlv-det">'+esc(c.detail)+'</span>' : '')+'</li>';
+    }).join('');
+    return '<ul class="szlv-checks">'+rows+'</ul>';
+  }
+
+  function renderResult(res){
+    // res is the {ok,status,data,err,aborted} envelope from pull()
+    if(res.status===429){
+      return '<div class="szlv-state fail">rate-limited · the fabric caps at 60/min per IP. '+
+             'This is honest backpressure, not a failure of your receipt. Try again shortly.</div>';
+    }
+    if(!res.ok || !res.data){
+      var why = res.aborted ? 'timed out' : (res.status ? ('HTTP '+res.status) : 'unreachable');
+      return '<div class="szlv-state muted">offline · fabric '+esc(why)+
+             '. No verdict shown — the widget never invents a green. '+
+             'Re-run the checks yourself per docs/developers/VERIFY.md.</div>';
+    }
+    var d = res.data;
+    var vv = verdictView(d.verdict);
+    var head = '<div class="szlv-verdict '+vv.cls+'">'+
+      '<span class="szlv-dot"></span><b>'+esc(vv.label)+'</b>'+
+      (vv.advisory ? '<span class="szlv-adv">advisory · not a cryptographic green</span>' : '')+
+      '</div>';
+    var detail = d.detail ? '<p class="szlv-detail">'+esc(d.detail)+'</p>' : '';
+    var kinds  = (Array.isArray(d.kinds)&&d.kinds.length)
+      ? '<p class="szlv-kinds">recognised as: '+d.kinds.map(esc).join(', ')+'</p>' : '';
+    var checks = renderChecks(d.checks);
+    var foot = '<p class="szlv-foot">engine '+esc(d.engine_version||d.service||'?')+
+      ' · doctrine '+esc((d.doctrine&&d.doctrine.version)||'v11')+
+      ' · Λ='+esc((d.doctrine&&d.doctrine.lambda)||'Conjecture 1')+
+      (d.verified_at ? ' · '+esc(d.verified_at) : '')+
+      '<br><span class="szlv-trust">No trust in the server is required — re-verify with cosign / rekor-cli / lake build.</span></p>';
+    return head+detail+kinds+checks+foot;
+  }
+
+  var CSS = [
+    '.szlv{font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;',
+    'color:#cdccca;background:#1c1b19;border:1px solid #393836;border-radius:10px;padding:16px;max-width:640px}',
+    '.szlv h3{font-size:15px;margin:0 0 4px;font-weight:600;letter-spacing:.2px}',
+    '.szlv .szlv-sub{font-size:12px;color:#797876;margin:0 0 12px}',
+    '.szlv textarea{width:100%;min-height:120px;box-sizing:border-box;background:#171614;color:#cdccca;',
+    'border:1px solid #393836;border-radius:8px;padding:10px;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;resize:vertical}',
+    '.szlv-row{display:flex;gap:8px;flex-wrap:wrap;margin:10px 0}',
+    '.szlv input[type=text]{flex:1;min-width:200px;background:#171614;color:#cdccca;border:1px solid #393836;border-radius:8px;padding:8px 10px;font-size:12px}',
+    '.szlv button{background:#01696f;color:#fff;border:0;border-radius:8px;padding:9px 16px;font-size:13px;font-weight:600;cursor:pointer}',
+    '.szlv button:hover{background:#0c4e54}.szlv button:disabled{opacity:.5;cursor:wait}',
+    '.szlv button.ghost{background:transparent;color:#4f98a3;border:1px solid #393836}',
+    '.szlv-out{margin-top:12px;font-size:13px;min-height:24px}',
+    '.szlv-load{color:#797876;font-size:12px}',
+    '.szlv-verdict{display:flex;align-items:center;gap:8px;font-size:15px;padding:8px 10px;border-radius:8px;border:1px solid #393836}',
+    '.szlv-verdict .szlv-dot{width:9px;height:9px;border-radius:50%}',
+    '.szlv-verdict.ok .szlv-dot{background:#6daa45}.szlv-verdict.ok{border-color:#3a5a26}',
+    '.szlv-verdict.warn .szlv-dot{background:#e8af34}.szlv-verdict.warn{border-color:#6b5418}',
+    '.szlv-verdict.fail .szlv-dot{background:#d163a7}.szlv-verdict.fail{border-color:#7a2c5a}',
+    '.szlv-verdict.muted .szlv-dot{background:#797876}',
+    '.szlv-adv{font-size:11px;color:#e8af34;font-weight:400;margin-left:auto}',
+    '.szlv-detail{font-size:12px;color:#a9a8a5;margin:8px 0}',
+    '.szlv-kinds{font-size:11px;color:#797876;margin:4px 0}',
+    '.szlv-checks{list-style:none;margin:8px 0 0;padding:0;display:flex;flex-direction:column;gap:4px}',
+    '.szlv-chk{display:flex;align-items:center;gap:8px;font-size:12px;flex-wrap:wrap}',
+    '.szlv-pill{font-size:10px;text-transform:uppercase;letter-spacing:.4px;padding:2px 6px;border-radius:4px;font-weight:700}',
+    '.szlv-pill.ok{background:rgba(109,170,69,.18);color:#6daa45}',
+    '.szlv-pill.fail{background:rgba(209,99,167,.18);color:#d163a7}',
+    '.szlv-pill.warn{background:rgba(232,175,52,.14);color:#e8af34}',
+    '.szlv-pill.muted{background:#2a2927;color:#797876}',
+    '.szlv-chk code{color:#cdccca}.szlv-det{color:#797876;font-size:11px}',
+    '.szlv-foot{font-size:10px;color:#5a5957;margin:10px 0 0;line-height:1.5}',
+    '.szlv-trust{color:#797876}',
+    '.szlv-state{font-size:12px;padding:8px 10px;border-radius:8px}',
+    '.szlv-state.fail{background:rgba(209,99,167,.10);color:#d163a7}',
+    '.szlv-state.muted{background:#211f1d;color:#a9a8a5}'
+  ].join('');
+
+  function injectCSS(){
+    if(document.getElementById('szlv-css')) return;
+    var st = document.createElement('style'); st.id='szlv-css'; st.textContent = CSS;
+    document.head.appendChild(st);
+  }
+
+  /* Public mount: SZLVerify.mount('#id', {base})  ------------------------- */
+  function mount(target, opts){
+    opts = opts || {};
+    var base = (opts.base || DEFAULT_BASE).replace(/\/+$/,'');
+    var host = (typeof target==='string') ? document.querySelector(target) : target;
+    if(!host) return null;
+    injectCSS();
+    host.classList.add('szlv');
+    host.innerHTML =
+      '<h3>ask the fabric — verify a receipt</h3>'+
+      '<p class="szlv-sub">Paste a Khipu receipt / DSSE envelope / in-toto statement, '+
+      'or fetch a public receipt by URL. Verdicts are the fabric\u2019s real, honest output '+
+      '(unsigned \u2192 STRUCTURAL-ONLY, never a false green).</p>'+
+      '<textarea class="szlv-ta" spellcheck="false"></textarea>'+
+      '<div class="szlv-row">'+
+        '<input type="text" class="szlv-url" placeholder="\u2026or a public receipt URL (https://\u2026/receipt.json)">'+
+      '</div>'+
+      '<div class="szlv-row">'+
+        '<button class="szlv-go" type="button">Verify</button>'+
+        '<button class="szlv-sample ghost" type="button">Load sample receipt</button>'+
+      '</div>'+
+      '<div class="szlv-out" aria-live="polite"></div>';
+
+    var ta  = host.querySelector('.szlv-ta');
+    var url = host.querySelector('.szlv-url');
+    var out = host.querySelector('.szlv-out');
+    var go  = host.querySelector('.szlv-go');
+    var smp = host.querySelector('.szlv-sample');
+
+    smp.addEventListener('click', function(){ ta.value = JSON.stringify(SAMPLE, null, 2); url.value=''; });
+
+    go.addEventListener('click', function(){
+      go.disabled = true;
+      out.innerHTML = '<span class="szlv-load">calling <code>'+esc(base+VERIFY_PATH)+'</code>\u2026</span>';
+      var p, u = url.value.trim(), body = ta.value.trim();
+      if(u){
+        p = pull(u, {method:'GET'}).then(function(remote){
+          if(!remote.ok || !remote.data) return remote;
+          var env = remote.data.envelope || remote.data.dsse || remote.data;
+          return pull(base+VERIFY_PATH, {method:'POST', headers:{'Content-Type':'application/json'},
+            body: JSON.stringify({envelope:env})});
+        });
+      } else if(body){
+        var parsed = null;
+        try{ parsed = JSON.parse(body); }catch(e){
+          out.innerHTML = '<div class="szlv-state muted">input is not valid JSON — paste a receipt object or use a URL.</div>';
+          go.disabled = false; return;
+        }
+        var requestBody = parsed.envelope ? parsed : {envelope:parsed};
+        p = pull(base+VERIFY_PATH, {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(requestBody)});
+      } else {
+        out.innerHTML = '<div class="szlv-state muted">paste a receipt JSON, or enter a public receipt URL.</div>';
+        go.disabled = false; return;
+      }
+      p.then(function(res){ out.innerHTML = renderResult(res); go.disabled = false; });
+    });
+
+    return { reload:function(){}, base:base };
+  }
+
+  var api = { mount: mount, pull: pull, _sample: SAMPLE, version: '1.1.0' };
+  if (typeof module!=='undefined' && module.exports) module.exports = api;
+  global.SZLVerify = api;
+})(typeof window!=='undefined' ? window : this);

live-body.html

@@ -0,0 +1,555 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<!-- SAFE-NOW hardening (R2): browser-honored CSP subset + nosniff + Referrer-Policy.
+     HSTS / frame-ancestors omitted (browsers ignore them in <meta>; setting them
+     would be fabrication). 'unsafe-inline' is required: this page ships an inline
+     module script + inline styles, and Three.js is a vendored same-origin script. -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self'; connect-src 'self' https://szlholdings-a11oy.hf.space https://a-11-oy.com; object-src 'none'; base-uri 'self'; form-action 'self'" />
+<meta http-equiv="X-Content-Type-Options" content="nosniff" />
+<meta name="referrer" content="strict-origin-when-cross-origin" />
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=2" />
+<title>SZL Living Anatomy — BODY v1 · the Sovereign Org as one living organism</title>
+<meta name="description" content="Body v1: the Sovereign Org rendered as one living governed organism. CatmullRom Bezier-tube vessels = the one DSSE chain; GPU pulses = REAL receipts from /api/a11oy/v1/ledger; 4 organs (Reasoning/Policy/Operator/Receipts) glow LIVE or dim UNREACHABLE on real probes; Λ (F19) drives the double-beat heartbeat + overall glow; verticals & SLSA shown honestly as ROADMAP where no endpoint exists. Honest by construction. Λ = Conjecture 1." />
+<style>
+  :root{
+    --void:#080c14; --void2:#0b1120;
+    --proof:#3af4c8; --lattice:#5b8dee; --gold:#d7b96b; --warn:#e0795b;
+    --dim:#3a4456; --text:#e9eef7; --muted:#8b97b4; --faint:#5d6a8f;
+    --surface:rgba(11,17,32,0.72); --surface2:rgba(16,24,44,0.92);
+    --border:rgba(91,141,238,0.18); --border-strong:rgba(91,141,238,0.36);
+    --radius:14px; --blur:18px;
+    --font-d:"Space Grotesk",ui-sans-serif,system-ui,-apple-system,"Segoe UI",Inter,Roboto,sans-serif;
+    --font-m:"JetBrains Mono",ui-monospace,"SF Mono",Menlo,Consolas,monospace;
+    --shadow:0 18px 60px rgba(0,0,0,0.6);
+  }
+  *{box-sizing:border-box;margin:0;padding:0}
+  html,body{height:100%;background:var(--void);color:var(--text);
+    font-family:var(--font-d);-webkit-font-smoothing:antialiased;overflow:hidden}
+  a{color:var(--proof);text-decoration:none} a:hover{text-decoration:underline}
+
+  #scene{position:fixed;inset:0;display:block;touch-action:none}
+
+  /* ---- HUD overlay (does not steal scene pointer unless on a panel) ---- */
+  .hud{position:fixed;z-index:5;pointer-events:none}
+  .panel{pointer-events:auto;background:var(--surface);backdrop-filter:blur(var(--blur));
+    border:1px solid var(--border);border-radius:var(--radius);box-shadow:var(--shadow)}
+  .hdr{font-family:var(--font-m);font-size:9px;letter-spacing:.22em;text-transform:uppercase;
+    color:var(--faint);padding-bottom:8px;margin-bottom:9px;border-bottom:1px solid var(--border)}
+
+  /* top-left: title */
+  #title{top:16px;left:16px;max-width:min(46ch,calc(100vw - 32px))}
+  #title .eyebrow{font-family:var(--font-m);font-size:9px;letter-spacing:.26em;text-transform:uppercase;color:var(--faint);margin-bottom:6px}
+  #title h1{font-size:18px;font-weight:600;line-height:1.15;letter-spacing:-.01em}
+  #title h1 .accent{color:var(--proof)}
+  #title .sub{font-size:11px;color:var(--muted);margin-top:7px;line-height:1.45;padding:11px 14px 0;display:none}
+  #title .inner{padding:13px 14px}
+
+  /* top-right: mind posture + Λ */
+  #mind{top:16px;right:16px;width:min(290px,calc(100vw - 32px));padding:13px 15px}
+  #mind .hdr{display:flex;justify-content:space-between;align-items:center}
+  #mind .row{display:flex;gap:9px;align-items:baseline;font-size:11.5px;line-height:1.5;color:var(--muted);margin-bottom:5px}
+  #mind .row:last-child{margin-bottom:0}
+  #mind .row .k{flex:0 0 64px;color:var(--faint);font-family:var(--font-m);font-size:9.5px;letter-spacing:.04em;text-transform:uppercase}
+  #mind .row b{color:var(--text);font-weight:600;font-family:var(--font-m);font-size:11px}
+  .badge{display:inline-block;font-family:var(--font-m);font-size:9.5px;letter-spacing:.03em;padding:2px 8px;border-radius:99px;border:1px solid currentColor;white-space:nowrap}
+  .sov-true{color:var(--proof)} .sov-false{color:var(--warn)} .sov-unknown{color:var(--faint)}
+  #lambda-wrap{margin-top:10px;padding-top:10px;border-top:1px solid var(--border)}
+  #lambda-val{font-family:var(--font-m);font-size:21px;font-weight:600;color:var(--gold);letter-spacing:.01em}
+  #lambda-meta{font-family:var(--font-m);font-size:9.5px;color:var(--faint);margin-top:3px;line-height:1.4}
+  #ecg{width:100%;height:34px;margin-top:8px;display:block}
+
+  /* bottom-left: organ status list */
+  #organs{bottom:16px;left:16px;width:min(290px,calc(100vw - 32px));padding:13px 15px}
+  .orow{display:flex;align-items:center;gap:9px;font-size:11.5px;line-height:1.45;margin-bottom:8px}
+  .orow:last-child{margin-bottom:0}
+  .odot{flex:0 0 auto;width:9px;height:9px;border-radius:50%;background:var(--dim);box-shadow:0 0 0 transparent;transition:all .3s}
+  .orow[data-state="live"] .odot{box-shadow:0 0 9px currentColor}
+  .orow .on{font-weight:600;color:var(--text);min-width:74px;font-size:11px}
+  .orow .od{font-family:var(--font-m);font-size:9.5px;color:var(--muted);line-height:1.35}
+  .orow[data-state="unreachable"] .od{color:var(--faint)}
+  .orow[data-state="pending"] .odot{animation:breathe 1.1s ease-in-out infinite}
+  @keyframes breathe{0%,100%{opacity:.35}50%{opacity:1}}
+
+  /* bottom-right: controls + log + honesty */
+  #side{bottom:16px;right:16px;width:min(320px,calc(100vw - 32px));padding:13px 15px}
+  .controls{display:flex;gap:8px;flex-wrap:wrap;margin-bottom:10px}
+  .btn{font-family:var(--font-m);font-size:10.5px;letter-spacing:.02em;color:var(--muted);background:var(--surface2);
+    border:1px solid var(--border);border-radius:99px;padding:8px 13px;cursor:pointer;transition:all .16s}
+  .btn:hover{border-color:var(--border-strong);color:var(--text);transform:translateY(-1px)}
+  .btn:focus-visible{outline:2px solid var(--lattice);outline-offset:2px}
+  .btn.primary{color:var(--proof);border-color:rgba(58,244,200,.45);background:rgba(58,244,200,.07)}
+  .btn[aria-disabled="true"]{opacity:.5;cursor:progress}
+  #log{font-family:var(--font-m);font-size:10px;color:var(--faint);line-height:1.55;min-height:2.6em;max-height:84px;overflow:auto}
+  #log b{color:var(--muted)}
+  #honesty{margin-top:10px;padding-top:10px;border-top:1px solid var(--border);font-size:10px;color:var(--faint);line-height:1.5}
+  #honesty b{color:var(--muted);font-weight:600}
+  .sw{display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--proof);box-shadow:0 0 6px currentColor;color:var(--proof);margin-right:5px;vertical-align:middle}
+
+  .legend{position:fixed;z-index:5;left:50%;bottom:14px;transform:translateX(-50%);pointer-events:none;
+    display:flex;gap:14px;font-family:var(--font-m);font-size:9px;letter-spacing:.04em;color:var(--faint);
+    background:rgba(8,12,20,.55);padding:6px 13px;border-radius:99px;border:1px solid var(--border)}
+  .legend span{display:flex;align-items:center;gap:5px}
+  .legend i{width:8px;height:8px;border-radius:2px;display:inline-block}
+
+  #boot{position:fixed;inset:0;z-index:9;display:flex;align-items:center;justify-content:center;
+    background:var(--void);color:var(--faint);font-family:var(--font-m);font-size:12px;letter-spacing:.08em}
+
+  /* tighten on small screens: hide secondary panels, keep mind + organs + log */
+  @media (max-width:760px){
+    #title{max-width:calc(100vw - 32px)} #title h1{font-size:15px}
+    #mind,#organs,#side{width:calc(100vw - 32px)}
+    #organs{bottom:auto;top:auto;display:none}        /* avoid overlap on phones */
+    .legend{font-size:8px;gap:9px;bottom:10px}
+  }
+  @media (prefers-reduced-motion:reduce){
+    .orow[data-state="pending"] .odot{animation:none}
+  }
+</style>
+</head>
+<body>
+<canvas id="scene" aria-label="3D living organism of the Sovereign Org"></canvas>
+<div id="boot">initializing living body…</div>
+
+<div class="hud" id="title"><div class="inner">
+  <div class="eyebrow">SZL Living Anatomy · body v1</div>
+  <h1>The Sovereign Org as <span class="accent">one living organism</span></h1>
+  <div class="sub">Vessels are the one DSSE chain. Each travelling pulse is a REAL receipt
+    from the ledger; each organ glows only on a real probe; Λ drives the heartbeat.
+    <a href="./index.html">← full 3D atlas</a></div>
+</div></div>
+
+<div class="hud panel" id="mind" aria-live="polite">
+  <div class="hdr"><span>GPU mind · posture</span><span>/code/healthz</span></div>
+  <div class="row"><span class="k">sovereign</span><span id="m-sov" class="badge sov-unknown">…</span></div>
+  <div class="row"><span class="k">backend</span><b id="m-backend">…</b></div>
+  <div class="row"><span class="k">mode</span><b id="m-mode">…</b></div>
+  <div class="row"><span class="k">doctrine</span><b id="m-doctrine">…</b></div>
+  <div id="lambda-wrap">
+    <div id="lambda-val">Λ …</div>
+    <div id="lambda-meta">heartbeat driver · /v1/lambda</div>
+    <canvas id="ecg" width="560" height="68" aria-hidden="true"></canvas>
+  </div>
+</div>
+
+
+  <div class="hud panel" id="integrity" style="top:auto;bottom:16px;left:16px;width:min(290px,calc(100vw - 32px));padding:13px 15px;transform:translateY(-210px)">
+    <div class="hdr">fail-closed kernel</div>
+    <div id="integrity-strip" data-state="pending" style="font-family:var(--font-m);font-size:10.5px;color:var(--muted);line-height:1.45">organ-integrity not yet polled</div>
+    <div style="margin-top:8px;font-size:10px;color:var(--faint)">GET /api/anatomy/v1/organs/integrity · energy UNAVAILABLE · Λ = Conjecture 1</div>
+  </div>
+
+  <div class="hud panel" id="organs" aria-live="polite">
+  <div class="hdr">organs · honest probes</div>
+  <div id="organ-rows"></div>
+</div>
+
+<div class="hud panel" id="side">
+  <div class="controls">
+    <button id="run" class="btn primary" type="button">▶ Run proactive cycle</button>
+    <button id="refresh" class="btn" type="button">↻ Refresh</button>
+  </div>
+  <div id="log" aria-live="polite"></div>
+  <div id="honesty">
+    <span class="sw"></span><b id="h-lambda">Λ = Conjecture 1</b> — advisory, never green.<br>
+    <span class="sw"></span><b>Verticals</b> &amp; <b>SLSA</b>: no live endpoint → honest ROADMAP, no fake flow.<br>
+    <span class="sw"></span>Read-only · no key sent · open-weight.
+  </div>
+</div>
+
+<div class="legend hud">
+  <span><i style="background:var(--proof)"></i>live receipt pulse</span>
+  <span><i style="background:var(--warn)"></i>denied gate</span>
+  <span><i style="background:var(--gold)"></i>Λ heartbeat</span>
+  <span><i style="background:var(--dim)"></i>unreachable / roadmap</span>
+</div>
+
+<script src="./lib/three.min.js"></script>
+<script type="module">
+import LiveBody from "./live-body.js";
+const THREE = window.THREE;
+const K = LiveBody.KANCHAY;
+const $ = (id) => document.getElementById(id);
+
+/* ============================ scene scaffold ============================== */
+const canvas = $("scene");
+const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: false });
+renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
+renderer.setClearColor(new THREE.Color(K.void), 1);
+
+const scene = new THREE.Scene();
+scene.fog = new THREE.FogExp2(new THREE.Color(K.void), 0.085);
+const camera = new THREE.PerspectiveCamera(46, 1, 0.1, 100);
+camera.position.set(0, 0.2, 6.2);
+
+scene.add(new THREE.AmbientLight(0x4a5878, 0.9));
+const key = new THREE.PointLight(0x9fc2ff, 1.1, 40); key.position.set(4, 6, 8); scene.add(key);
+const rim = new THREE.PointLight(0x3af4c8, 0.7, 40); rim.position.set(-6, -3, 4); scene.add(rim);
+
+const root = new THREE.Group(); scene.add(root);   // everything rotatable
+
+/* radial glow sprite texture (additive "selective bloom" — no jsm composer vendored) */
+function glowTexture() {
+  const s = 64, c = document.createElement("canvas"); c.width = c.height = s;
+  const g = c.getContext("2d");
+  const grd = g.createRadialGradient(s/2, s/2, 0, s/2, s/2, s/2);
+  grd.addColorStop(0, "rgba(255,255,255,1)");
+  grd.addColorStop(0.25, "rgba(255,255,255,0.55)");
+  grd.addColorStop(1, "rgba(255,255,255,0)");
+  g.fillStyle = grd; g.fillRect(0, 0, s, s);
+  const t = new THREE.CanvasTexture(c); t.needsUpdate = true; return t;
+}
+const GLOW = glowTexture();
+function glowSprite(color, scale, opacity) {
+  const m = new THREE.SpriteMaterial({ map: GLOW, color: new THREE.Color(color),
+    transparent: true, opacity, blending: THREE.AdditiveBlending, depthWrite: false });
+  const sp = new THREE.Sprite(m); sp.scale.set(scale, scale, 1); return sp;
+}
+
+/* ============================ organs ===================================== */
+const organMeshes = new Map();   // id -> {core, halo, color, baseEmissive, pos}
+const ORGAN_GEO = {
+  reasoning: () => new THREE.IcosahedronGeometry(0.32, 1),
+  policy:    () => new THREE.DodecahedronGeometry(0.30, 0),
+  operator:  () => new THREE.OctahedronGeometry(0.32, 1),
+  receipts:  () => new THREE.IcosahedronGeometry(0.40, 2),   // the heart hub (center-low)
+};
+for (const o of LiveBody.ORGANS) {
+  const geo = (ORGAN_GEO[o.id] || (() => new THREE.IcosahedronGeometry(0.3, 1)))();
+  const col = new THREE.Color(o.color);
+  const mat = new THREE.MeshStandardMaterial({
+    color: col, emissive: col, emissiveIntensity: 0.15,
+    metalness: 0.2, roughness: 0.45, flatShading: true });
+  const core = new THREE.Mesh(geo, mat);
+  core.position.set(o.pos[0], o.pos[1], o.pos[2]);
+  const halo = glowSprite(o.color, 1.25, 0.0); halo.position.copy(core.position);
+  root.add(core); root.add(halo);
+  organMeshes.set(o.id, { core, halo, color: col, mat, pos: core.position.clone() });
+}
+const HEART = organMeshes.get("receipts");   // Λ heartbeat target
+
+/* ============================ vessels (the chain) ======================== *
+ * One CatmullRom Bezier tube from each organ to the heart (RECEIPTS). These ARE
+ * the one DSSE chain; pulses travel them. <12 tubes => trivial draw-call cost. */
+const vessels = new Map();   // organId -> {curve, mesh}
+function makeVessel(fromPos, toPos, color) {
+  const mid = fromPos.clone().lerp(toPos, 0.5);
+  const bow = fromPos.clone().sub(toPos); // perpendicular-ish bow for a vessel look
+  mid.add(new THREE.Vector3(-bow.y, bow.x, bow.z * 0.5).multiplyScalar(0.28));
+  mid.z += 0.35;
+  const curve = new THREE.CatmullRomCurve3([fromPos.clone(), mid, toPos.clone()]);
+  const geo = new THREE.TubeGeometry(curve, 40, 0.018, 6, false);
+  const mat = new THREE.MeshBasicMaterial({ color: new THREE.Color(color),
+    transparent: true, opacity: 0.22 });
+  const mesh = new THREE.Mesh(geo, mat); root.add(mesh);
+  return { curve, mesh };
+}
+for (const o of LiveBody.ORGANS) {
+  if (o.id === "receipts") continue;
+  vessels.set(o.id, makeVessel(organMeshes.get(o.id).pos, HEART.pos, K.lattice));
+}
+
+/* ============================ verticals (limbs) ========================== *
+ * Honest ROADMAP: rendered, dim, labeled — never fake-pulsed (no live throughput
+ * endpoint). They wake only if a real "<vertical>|<action>" receipt arrives. */
+const limbs = new Map();
+for (const v of LiveBody.VERTICALS) {
+  const geo = new THREE.TorusGeometry(0.16, 0.045, 8, 16);
+  const col = new THREE.Color(v.color);
+  const mat = new THREE.MeshStandardMaterial({ color: col, emissive: col,
+    emissiveIntensity: 0.04, metalness: 0.3, roughness: 0.6, flatShading: true });
+  const m = new THREE.Mesh(geo, mat); m.position.set(v.pos[0], v.pos[1], v.pos[2]);
+  m.rotation.x = Math.PI / 2; root.add(m);
+  // honest dashed tether to torso (structure only, not a chain vessel)
+  limbs.set(v.id, { mesh: m, color: col });
+}
+
+/* ============================ skeleton (SLSA) ============================ *
+ * Structural spine ring. Honest: no /v1/slsa endpoint => integrity UNVERIFIED;
+ * rendered as faint structure, never claiming a verified SLSA level. */
+const spineMat = new THREE.MeshBasicMaterial({ color: new THREE.Color(K.dim),
+  transparent: true, opacity: 0.16, wireframe: true });
+const spine = new THREE.Mesh(new THREE.TorusGeometry(1.55, 0.012, 4, 48), spineMat);
+spine.rotation.x = Math.PI / 2.2; root.add(spine);
+
+/* ============================ immune swarm (E5) ========================== *
+ * GPU-instanced antibodies. count = REAL fraction of mesh engines down
+ * (/v1/govern/health). Dormant (count 0) when the mesh is healthy. */
+const SWARM_MAX = 1200;
+const swarmGeo = new THREE.SphereGeometry(0.018, 6, 6);
+const swarmMat = new THREE.MeshBasicMaterial({ color: new THREE.Color(K.warn),
+  transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending, depthWrite: false });
+const swarm = new THREE.InstancedMesh(swarmGeo, swarmMat, SWARM_MAX);
+swarm.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+swarm.count = 0; root.add(swarm);
+const swarmSeed = [];
+for (let i = 0; i < SWARM_MAX; i++) {
+  swarmSeed.push({ r: 0.55 + Math.random() * 0.5, a: Math.random() * Math.PI * 2,
+    b: Math.random() * Math.PI, sp: 0.4 + Math.random() * 0.8 });
+}
+const _m = new THREE.Matrix4(), _v = new THREE.Vector3();
+
+/* ============================ pulse pool ================================= *
+ * Each active pulse corresponds to a REAL receipt. Pooled so we never exceed the
+ * perf budget; LIVE pulses recycle. Denied receipts bounce back at the organ wall. */
+const POOL = 48;
+const pulseCore = [];
+for (let i = 0; i < POOL; i++) {
+  const grp = new THREE.Group();
+  const core = new THREE.Mesh(new THREE.SphereGeometry(0.05, 8, 8),
+    new THREE.MeshBasicMaterial({ color: 0xffffff }));
+  const gl = glowSprite("#ffffff", 0.42, 0.9); grp.add(core); grp.add(gl);
+  grp.visible = false; root.add(grp);
+  pulseCore.push({ grp, core, gl, active: false, t: 0, speed: 0.0, curve: null,
+    color: new THREE.Color(K.proof), denied: false, dir: 1 });
+}
+function spawnPulse(organId, color, denied) {
+  const v = vessels.get(organId) || vessels.get("policy");
+  if (!v) return;
+  const p = pulseCore.find((x) => !x.active);
+  if (!p) return;   // pool exhausted this frame; honest backpressure (no over-budget spawns)
+  p.active = true; p.t = 0; p.dir = 1; p.denied = !!denied;
+  p.speed = 0.45 + Math.random() * 0.2;
+  p.curve = v.curve; p.color.set(denied ? K.warn : (color || K.proof));
+  p.core.material.color.copy(p.color); p.gl.material.color.copy(p.color);
+  p.grp.visible = true;
+}
+
+/* ============================ HUD: organ rows ============================ */
+const organRows = new Map();
+for (const o of LiveBody.ORGANS) {
+  const row = document.createElement("div");
+  row.className = "orow"; row.dataset.state = "pending";
+  row.innerHTML =
+    `<span class="odot" style="color:${o.color}"></span>
+     <span class="on">${o.name}</span>
+     <span class="od">probing…</span>`;
+  $("organ-rows").appendChild(row);
+  organRows.set(o.id, row);
+}
+function setOrganDot(row, state, color) {
+  const dot = row.querySelector(".odot");
+  dot.style.background = state === "live" ? color : "var(--dim)";
+}
+
+/* ============================ live data wiring =========================== */
+const STATE = { lambda: 0.90, lambdaPass: true, organLive: {}, lastSeq: -1, immune: 0 };
+let seenIds = new Set();
+
+function logLine(html) {
+  const el = $("log");
+  el.innerHTML = html + "<br>" + el.innerHTML;
+  if (el.innerHTML.length > 2400) el.innerHTML = el.innerHTML.slice(0, 2400);
+}
+
+async function refreshOrgans() {
+  await Promise.all(LiveBody.ORGANS.map(async (o) => {
+    const r = await LiveBody.probeOrgan(o);
+    const row = organRows.get(o.id);
+    row.dataset.state = r.status;
+    const od = row.querySelector(".od");
+    if (r.status === LiveBody.STATUS.LIVE) {
+      od.textContent = r.detail; setOrganDot(row, "live", o.color);
+      STATE.organLive[o.id] = true;
+      const om = organMeshes.get(o.id);
+      om.mat.emissiveIntensity = 0.6;        // healthy glow
+    } else {
+      od.textContent = `unreachable — ${r.detail} · honest empty-state`;
+      setOrganDot(row, "unreachable"); STATE.organLive[o.id] = false;
+      organMeshes.get(o.id).mat.emissiveIntensity = 0.06;   // dim, honest
+    }
+  }));
+}
+
+async function refreshMind() {
+  const m = await LiveBody.fetchMind();
+  const sov = $("m-sov");
+  if (!m.reachable) {
+    sov.className = "badge sov-unknown"; sov.textContent = "unknown";
+    $("m-backend").textContent = "unreachable"; $("m-mode").textContent = m.why || "—";
+    $("m-doctrine").textContent = "—"; return;
+  }
+  if (m.sovereign === true) { sov.className = "badge sov-true"; sov.textContent = "true (local serves)"; }
+  else { sov.className = "badge sov-false"; sov.textContent = "false (router serves)"; }
+  $("m-backend").textContent = m.backend; $("m-mode").textContent = m.mode;
+  $("m-doctrine").textContent = m.doctrine || "—";
+}
+
+async function refreshLambda() {
+  const d = await LiveBody.fetchLambda();
+  if (!d.reachable || d.lambda == null) {
+    $("lambda-val").textContent = "Λ unreachable";
+    $("lambda-meta").textContent = `${d.why || "no data"} · honest empty-state`;
+    return;
+  }
+  STATE.lambda = d.lambda; STATE.lambdaPass = d.pass;
+  $("lambda-val").textContent = `Λ ${d.lambda.toFixed(5)}`;
+  $("lambda-meta").textContent =
+    `${d.pass ? "≥" : "<"} floor ${d.floor} · ${d.axes.length}-axis ${d.aggregate ? "· " + d.aggregate.split("(")[0].trim() : ""}`;
+  $("h-lambda").textContent = `Λ = ${d.uniqueness}`;
+}
+
+async function refreshDoctrine() {
+  const d = await LiveBody.fetchDoctrine();
+  if (!d.reachable) return;
+  $("h-lambda").textContent = `Λ = ${d.lambda}`;
+}
+
+async function refreshImmune() {
+  const im = await LiveBody.fetchImmune();
+  STATE.immune = im.reachable ? im.intensity : 0;
+  swarm.count = Math.round(STATE.immune * SWARM_MAX);
+  if (im.reachable) logLine(`<b>immune:</b> ${im.detail}`);
+}
+
+/* spawn pulses for REAL receipts we haven't shown yet (honest: 1 pulse / receipt) */
+async function refreshLedger(initial) {
+  const L = await LiveBody.fetchLedger();
+  if (!L.reachable) {
+    logLine(`<b>ledger:</b> UNREACHABLE — ${L.why} · no pulses faked.`);
+    return 0;
+  }
+  let spawned = 0;
+  const recent = L.receipts.slice(-POOL);   // cap to pool; never exceed budget
+  for (const r of recent) {
+    if (seenIds.has(r.id)) continue;
+    seenIds.add(r.id);
+    if (!initial) {                         // on refresh, only animate genuinely-new receipts
+      spawnPulse(r.organ, organMeshes.get(r.organ)?.color.getStyle(), r.denied);
+      spawned++;
+    }
+  }
+  logLine(`<b>ledger:</b> ${L.count} receipts on the chain${spawned ? ` · +${spawned} new pulse(s)` : ""}.`);
+  return L.count;
+}
+
+async function refreshAll(initial) {
+  await Promise.all([refreshOrgans(), refreshMind(), refreshLambda(), refreshDoctrine(), refreshImmune()]);
+  await refreshLedger(initial);
+}
+
+/* the proactive cycle: replay the REAL chain's organ order as travelling pulses */
+let running = false;
+async function runCycle() {
+  if (running) return; running = true;
+  const btn = $("run"); btn.setAttribute("aria-disabled", "true");
+  const L = await LiveBody.fetchLedger();
+  if (!L.reachable) {
+    logLine(`<b>cycle:</b> ledger UNREACHABLE — ${L.why}; nothing faked.`);
+    btn.removeAttribute("aria-disabled"); running = false; return;
+  }
+  logLine(`<b>proactive cycle:</b> replaying ${L.receipts.length} real receipts…`);
+  for (const r of L.receipts) {
+    spawnPulse(r.organ, organMeshes.get(r.organ)?.color.getStyle(), r.denied);
+    await sleep(150);
+  }
+  logLine(`<b>cycle complete</b> — every pulse was a real receipt (seq 0…${L.receipts.length - 1}).`);
+  btn.removeAttribute("aria-disabled"); running = false;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/* ============================ Λ heartbeat (E7) =========================== *
+ * Double-beat ECG waveform; rate scales with Λ. Drives heart scale + emissive
+ * and the overall organism glow. Honest: when Λ is unreachable it flatlines. */
+const ecg = $("ecg"), ectx = ecg.getContext("2d");
+let beatPhase = 0;
+function heartbeatEnvelope(phase) {
+  // two gaussian "lub-dub" bumps per cycle
+  const g = (c, w) => Math.exp(-((phase - c) ** 2) / (2 * w * w));
+  return g(0.18, 0.05) * 1.0 + g(0.34, 0.07) * 0.62;
+}
+function drawECG() {
+  const w = ecg.width, h = ecg.height; ectx.clearRect(0, 0, w, h);
+  ectx.strokeStyle = STATE.lambdaPass ? K.gold : K.warn; ectx.lineWidth = 1.6;
+  ectx.beginPath();
+  for (let x = 0; x <= w; x++) {
+    const ph = ((x / w) + beatPhase) % 1;
+    const y = h * 0.5 - heartbeatEnvelope(ph) * h * 0.42;
+    x === 0 ? ectx.moveTo(x, y) : ectx.lineTo(x, y);
+  }
+  ectx.stroke();
+}
+
+/* ============================ animation loop ============================= */
+let last = performance.now(), dragX = 0, dragY = 0, autoSpin = 0.04;
+function animate(now) {
+  const dt = Math.min(0.05, (now - last) / 1000); last = now;
+  // heartbeat rate from Λ (0.90→~0.8Hz, 1.0→~1.2Hz)
+  const rate = 0.8 + Math.max(0, STATE.lambda - 0.9) * 4;
+  beatPhase = (beatPhase + dt * rate) % 1;
+  const env = heartbeatEnvelope(beatPhase);
+  // heart pulse + overall glow
+  const s = 1 + env * 0.16; HEART.core.scale.setScalar(s);
+  HEART.mat.emissiveIntensity = (STATE.organLive.receipts ? 0.55 : 0.06) + env * 0.7;
+  HEART.halo.material.opacity = 0.12 + env * 0.4;
+  // organ halos track health + breathe with the beat
+  for (const [id, om] of organMeshes) {
+    const liveOn = STATE.organLive[id];
+    om.halo.material.opacity = (liveOn ? 0.16 : 0.0) + (liveOn ? env * 0.18 : 0);
+    om.core.rotation.y += dt * 0.25; om.core.rotation.x += dt * 0.12;
+  }
+  // verticals gently breathe but stay dim (honest ROADMAP)
+  for (const [, lb] of limbs) lb.mesh.rotation.z += dt * 0.2;
+  // pulses travel their vessel; denied bounce back at the organ wall
+  for (const p of pulseCore) {
+    if (!p.active) continue;
+    p.t += dt * p.speed * p.dir;
+    if (p.denied && p.t >= 0.82) { p.dir = -1; }     // rejected at the wall → bounce
+    if (p.t >= 1 || p.t <= 0) {
+      // arrived at heart (allow) or returned to organ (denied) → recycle
+      p.active = false; p.grp.visible = false; continue;
+    }
+    const pt = p.curve.getPointAt(Math.min(0.999, Math.max(0.001, p.t)));
+    p.grp.position.copy(pt);
+    // brighten the heart very slightly as an allow-pulse lands
+  }
+  // immune swarm orbit (instanced)
+  if (swarm.count > 0) {
+    for (let i = 0; i < swarm.count; i++) {
+      const sd = swarmSeed[i]; sd.a += dt * sd.sp;
+      _v.set(Math.sin(sd.b) * Math.cos(sd.a) * sd.r,
+             Math.cos(sd.b) * sd.r * 0.6,
+             Math.sin(sd.b) * Math.sin(sd.a) * sd.r);
+      _m.makeTranslation(_v.x, _v.y, _v.z); swarm.setMatrixAt(i, _m);
+    }
+    swarm.instanceMatrix.needsUpdate = true;
+  }
+  // gentle auto-spin + drag
+  root.rotation.y += dt * autoSpin + dragX; root.rotation.x += dragY;
+  root.rotation.x = Math.max(-0.5, Math.min(0.5, root.rotation.x));
+  dragX *= 0.85; dragY *= 0.85;
+  drawECG();
+  renderer.render(scene, camera);
+  requestAnimationFrame(animate);
+}
+
+/* ============================ resize + input ============================= */
+function resize() {
+  const w = window.innerWidth, h = window.innerHeight;
+  renderer.setSize(w, h, false); camera.aspect = w / h; camera.updateProjectionMatrix();
+}
+window.addEventListener("resize", resize); resize();
+
+let dragging = false, lx = 0, ly = 0;
+canvas.addEventListener("pointerdown", (e) => { dragging = true; lx = e.clientX; ly = e.clientY; autoSpin = 0; });
+window.addEventListener("pointerup", () => { dragging = false; autoSpin = 0.04; });
+window.addEventListener("pointermove", (e) => {
+  if (!dragging) return;
+  dragX = (e.clientX - lx) * 0.00018; dragY = (e.clientY - ly) * 0.00012;
+  lx = e.clientX; ly = e.clientY;
+});
+
+/* ============================ boot ======================================= */
+$("run").addEventListener("click", runCycle);
+$("refresh").addEventListener("click", () => refreshAll(false));
+(async () => {
+  await refreshAll(true);          // initial: seed seenIds without a pulse storm
+  $("boot").style.display = "none";
+  requestAnimationFrame(animate);
+  // a short delayed replay so the first load visibly shows real receipts flowing
+  setTimeout(runCycle, 400);
+})();
+</script>
+</body>
+</html>

live-body.js

@@ -0,0 +1,337 @@
+/* =============================================================================
+ * live-body.js — SZL Living Anatomy · BODY v1 ENGINE (the living face)
+ * =============================================================================
+ * The Sovereign Org rendered as ONE living governed organism. This module is the
+ * HONEST DATA SPINE for live-body.html's Three.js scene. It reads the SAME live
+ * a11oy endpoints the unified console reads and exposes them as honest records.
+ *
+ * CRITICAL DISCIPLINE (binding — honest by construction, never a screensaver):
+ *   - Every pulse travelling a vessel corresponds to a REAL receipt on the chain
+ *     (/api/a11oy/v1/ledger). We never synthesize a receipt.
+ *   - Every organ glows LIVE only on a real 2xx+JSON probe; otherwise it dims to an
+ *     honest UNREACHABLE state. We never fabricate a green light.
+ *   - sovereign:true is shown ONLY when /code/healthz reports the literal true.
+ *   - Λ is advisory and its uniqueness is Conjecture 1 — pulled live from
+ *     /v1/lambda + /v1/honest, never hardcoded as proven.
+ *   - Verticals (insurance/defense/finance/realestate), SLSA skeletal integrity,
+ *     and drift have NO live endpoint on this Space today, so they render in an
+ *     explicit ROADMAP / N-A state — limbs do NOT fake-pulse and the skeleton does
+ *     NOT claim a verified SLSA level. Honest absence over decorative motion.
+ *   - Read-only. No key is sent. open-weight only.
+ *
+ * No build step, no framework, no CDN — a plain ES module that runs as a static
+ * SDK page at the .static.hf.space URL, exactly like index.html.
+ * ============================================================================ */
+"use strict";
+
+/* ---- the single live host the console reads (verified live this session) --- */
+const HOST = "https://szlholdings-a11oy.hf.space";
+
+/* Real, verified endpoints (curl-checked 2026-06-30):
+ *   /api/a11oy/v1/ledger      -> {count, receipts:[{seq,action,receipt_id}]}  (THE chain)
+ *   /api/a11oy/v1/lambda      -> {trust_axes,axes[],lambda,lambda_floor,pass,uniqueness}
+ *   /api/a11oy/code/healthz   -> {sovereign,backend,mode,doctrine_state,...}
+ *   /api/a11oy/v1/honest      -> {doctrine_lock:{lambda,locked_formula_ids,...}}
+ *   /api/a11oy/readyz         -> {status,operator:{operator_running,...}}
+ *   /api/a11oy/v1/govern/health-> {engines_live,engines_total,mesh[]}            */
+const EP = {
+  ledger:  HOST + "/api/a11oy/v1/ledger",
+  lambda:  HOST + "/api/a11oy/v1/lambda",
+  healthz: HOST + "/api/a11oy/code/healthz",
+  honest:  HOST + "/api/a11oy/v1/honest",
+  readyz:  HOST + "/api/a11oy/readyz",
+  govern:  HOST + "/api/a11oy/v1/govern/health",
+  integrity: HOST + "/api/a11oy/v1/organs/integrity",
+};
+
+/* ---- KANCHAY palette (canonical brand · purple BANNED) -------------------- */
+const KANCHAY = {
+  void:    "#080c14",
+  proof:   "#3af4c8",   // teal — proven / live
+  lattice: "#5b8dee",   // blue — structure / vessels
+  gold:    "#d7b96b",   // gold — Λ / heartbeat accent
+  warn:    "#e0795b",   // ember — denied / down
+  dim:     "#3a4456",   // honest unreachable / dormant
+  text:    "#e9eef7",
+};
+
+/* ---- status vocabulary ---------------------------------------------------- */
+const STATUS = {
+  LIVE: "live",               // endpoint answered 2xx with usable JSON
+  UNREACHABLE: "unreachable", // network / non-2xx / not-JSON — honest unknown
+  PENDING: "pending",         // not yet polled
+};
+
+/* ---- the 4 console organs, each a REAL probe ------------------------------ *
+ * These are the organs the unified console shows (Reasoning/Policy/Operator/
+ * Receipts). Each maps to a real endpoint that proves it is alive; LIVE only on
+ * a real 2xx+JSON answer, otherwise an honest UNREACHABLE dim. `pos` is a normalized
+ * body-space anchor [x,y,z] the scene uses to place the organ. */
+const ORGANS = [
+  {
+    id: "reasoning", name: "REASONING", glyph: "✸", color: KANCHAY.proof,
+    pos: [0, 1.15, 0],
+    probe: "lambda",
+    role: "scores Λ (13-axis) + recommends the decision under uncertainty",
+    actions: ["lambda.score", "decision.recommend"],
+    summarize: (j) => {
+      if (typeof j.lambda === "number")
+        return `Λ ${j.lambda.toFixed(5)} ${j.pass ? "≥" : "<"} floor ${j.lambda_floor} · ${j.trust_axes || (j.axes||[]).length}-axis`;
+      return "reasoning responding";
+    },
+  },
+  {
+    id: "policy", name: "POLICY", glyph: "⛨", color: KANCHAY.gold,
+    pos: [-1.15, 0.15, 0.1],
+    probe: "honest",
+    role: "the deny-by-default gate (F12) — rejects unsafe / overclaiming work",
+    actions: ["gate.evaluate"],
+    summarize: (j) => {
+      const lk = j.doctrine_lock || {};
+      const ids = lk.locked_formula_ids || [];
+      const f12 = ids.includes("F12");
+      return `${lk.locked_formula_count ?? ids.length} locked · F12 gate ${f12 ? "armed" : "—"}`;
+    },
+  },
+  {
+    id: "operator", name: "OPERATOR", glyph: "⌁", color: KANCHAY.lattice,
+    pos: [1.15, 0.15, 0.1],
+    probe: "readyz",
+    role: "approves + executes admitted work; the hands of the organism",
+    actions: ["operator.approve"],
+    summarize: (j) => {
+      const op = j.operator || {};
+      if (op.operator_running === true) return `operator running · ${j.status || "ready"}`;
+      if (j.status) return `status: ${j.status}`;
+      return "operator responding";
+    },
+  },
+  {
+    id: "receipts", name: "RECEIPTS", glyph: "❤", color: KANCHAY.warn,
+    pos: [0, -1.15, 0],
+    probe: "ledger",
+    role: "signs + replays a verifiable receipt for every action (the heartbeat)",
+    actions: ["receipt.sign", "replay.verify"],
+    summarize: (j) => {
+      const rs = j.receipts || j.items || (Array.isArray(j) ? j : null);
+      const n = Array.isArray(rs) ? rs.length : (typeof j.count === "number" ? j.count : null);
+      return n != null ? `${n} receipts on the chain` : "receipt bus reachable";
+    },
+  },
+];
+
+/* Which organ a receipt action originates from (so a pulse leaves the right
+ * organ and travels to RECEIPTS/heart). Unknown actions default to receipts. */
+const ACTION_SOURCE = {
+  "gate.evaluate": "policy",
+  "lambda.score": "reasoning",
+  "decision.recommend": "reasoning",
+  "operator.approve": "operator",
+  "receipt.sign": "receipts",
+  "replay.verify": "receipts",
+};
+function organForAction(action) {
+  if (!action) return "receipts";
+  const a = String(action).toLowerCase();
+  if (ACTION_SOURCE[a]) return ACTION_SOURCE[a];
+  // honest heuristic for verbs we haven't enumerated
+  if (a.startsWith("gate")) return "policy";
+  if (a.startsWith("lambda") || a.includes("decision") || a.includes("reason")) return "reasoning";
+  if (a.includes("operator") || a.includes("approve") || a.includes("execute")) return "operator";
+  return "receipts";
+}
+/* An action is a DENIAL (rejected pulse) only when it honestly says so. */
+function isDenied(action) {
+  const a = String(action || "").toLowerCase();
+  return a.includes("deny") || a.includes("denied") || a.includes("reject") || a.includes("block");
+}
+
+/* The 4 verticals = limbs. NO live throughput endpoint exists on this Space, so
+ * they render in an honest ROADMAP state and only pulse if a real receipt with a
+ * "<vertical>|<action>" verb appears on the chain. Never fake-pulsed. */
+const VERTICALS = [
+  { id: "insurance",  name: "INSURANCE",  pos: [-1.7, -0.7, 0.0], color: KANCHAY.proof },
+  { id: "defense",    name: "DEFENSE",    pos: [ 1.7, -0.7, 0.0], color: KANCHAY.lattice },
+  { id: "finance",    name: "FINANCE",    pos: [-1.7,  0.9, 0.0], color: KANCHAY.gold },
+  { id: "realestate", name: "REALESTATE", pos: [ 1.7,  0.9, 0.0], color: KANCHAY.warn },
+];
+
+/* ---- one honest GET (never throws; no creds, no custom headers => simple CORS) */
+async function getJSON(url, timeoutMs = 9000) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "GET", mode: "cors", credentials: "omit",
+      signal: ctl.signal, cache: "no-store",
+    });
+    clearTimeout(t);
+    if (!res.ok) return { ok: false, why: `HTTP ${res.status}` };
+    const ct = res.headers.get("content-type") || "";
+    if (!ct.includes("json")) return { ok: false, why: "no JSON (route unmatched?)" };
+    return { ok: true, json: await res.json() };
+  } catch (e) {
+    clearTimeout(t);
+    return { ok: false, why: (e && e.name === "AbortError") ? "timeout" : "network/CORS" };
+  }
+}
+
+/* probe one organ honestly -> {status, detail, raw} */
+async function probeOrgan(organ, timeoutMs = 9000) {
+  const r = await getJSON(EP[organ.probe], timeoutMs);
+  if (!r.ok) return { status: STATUS.UNREACHABLE, detail: r.why, raw: null };
+  let detail;
+  try { detail = organ.summarize(r.json); }
+  catch { detail = "responding (shape unrecognized)"; }
+  return { status: STATUS.LIVE, detail, raw: r.json };
+}
+
+/* fetch the REAL receipt chain. Returns normalized receipts (or honest empty). */
+async function fetchLedger(timeoutMs = 9000) {
+  const r = await getJSON(EP.ledger, timeoutMs);
+  if (!r.ok) return { reachable: false, why: r.why, count: 0, receipts: [] };
+  const j = r.json;
+  const raw = j.receipts || j.items || (Array.isArray(j) ? j : []);
+  const receipts = (Array.isArray(raw) ? raw : []).map((x, i) => {
+    const action = x.action || x.verb || x.kind || "receipt";
+    return {
+      seq: typeof x.seq === "number" ? x.seq : i,
+      action,
+      id: x.receipt_id || x.id || x.hash || String(i),
+      organ: organForAction(action),
+      denied: isDenied(action),
+    };
+  });
+  return { reachable: true, count: j.count ?? receipts.length, receipts };
+}
+
+/* fetch Λ posture (heartbeat driver). Honest: uniqueness stays Conjecture 1. */
+async function fetchLambda(timeoutMs = 9000) {
+  const r = await getJSON(EP.lambda, timeoutMs);
+  if (!r.ok) return { reachable: false, why: r.why };
+  const j = r.json;
+  return {
+    reachable: true,
+    lambda: typeof j.lambda === "number" ? j.lambda : null,
+    floor: typeof j.lambda_floor === "number" ? j.lambda_floor : 0.90,
+    pass: j.pass === true,
+    axes: Array.isArray(j.axes) ? j.axes : [],
+    aggregate: j.aggregate || "",
+    uniqueness: j.uniqueness || "Conjecture 1",
+    raw: j,
+  };
+}
+
+/* fetch the GPU-mind posture (sovereign strict; default FALSE — never invent true) */
+async function fetchMind(timeoutMs = 9000) {
+  const r = await getJSON(EP.healthz, timeoutMs);
+  if (!r.ok) return { reachable: false, sovereign: false, why: r.why };
+  const j = r.json;
+  return {
+    reachable: true,
+    sovereign: j.sovereign === true,
+    backend: j.backend || j.inference || "unknown",
+    mode: j.mode || "unknown",
+    doctrine: j.doctrine_state ? `${j.doctrine || ""} ${j.doctrine_state}`.trim() : (j.doctrine || ""),
+    raw: j,
+  };
+}
+
+/* fetch doctrine / Λ lock for the honesty strip. */
+async function fetchDoctrine(timeoutMs = 9000) {
+  const r = await getJSON(EP.honest, timeoutMs);
+  if (!r.ok) return { reachable: false };
+  const lk = (r.json && r.json.doctrine_lock) || {};
+  return {
+    reachable: true,
+    lambda: lk.lambda || "Conjecture 1",
+    commit: lk.commit || "",
+    lockedCount: lk.locked_formula_count ?? 8,
+    lockedIds: lk.locked_formula_ids || [],
+    declarations: lk.declarations, axioms: lk.axioms, sorries: lk.sorries,
+    state: lk.state || "",
+  };
+}
+
+/* fetch mesh/engine health — the only REAL drift-ish signal available today:
+ * engines_total - engines_live antibodies. honest immune intensity in [0,1]. */
+async function fetchImmune(timeoutMs = 9000) {
+  const r = await getJSON(EP.govern, timeoutMs);
+  if (!r.ok) return { reachable: false, intensity: 0, detail: r.why };
+  const j = r.json;
+  const total = typeof j.engines_total === "number" ? j.engines_total : 0;
+  const live = typeof j.engines_live === "number" ? j.engines_live : total;
+  const down = Math.max(0, total - live);
+  return {
+    reachable: true,
+    intensity: total > 0 ? down / total : 0,   // real fraction of mesh down
+    down, live, total,
+    detail: down > 0 ? `${down}/${total} mesh engines down — antibodies active` : `mesh ${live}/${total} healthy`,
+  };
+}
+
+/* ---- the engine surface --------------------------------------------------- */
+const LiveBody = {
+  HOST, EP, KANCHAY, STATUS, ORGANS, VERTICALS,
+  organForAction, isDenied,
+  probeOrgan, fetchLedger, fetchLambda, fetchMind, fetchDoctrine, fetchImmune,
+};
+
+if (typeof window !== "undefined") window.LiveBody = LiveBody;
+export default LiveBody;
+export {
+  HOST, EP, KANCHAY, STATUS, ORGANS, VERTICALS,
+  organForAction, isDenied,
+  probeOrgan, fetchLedger, fetchLambda, fetchMind, fetchDoctrine, fetchImmune,
+};
+
+
+/* Five-organ fail-closed kernel overlay.
+ * Same-origin anatomy kernel first, then a-11-oy.com, then the a11oy Space.
+ * Missing API → UNAVAILABLE, never faked LIVE. */
+async function probeOrganIntegrity() {
+  const rec = { status: STATUS.PENDING, detail: "not yet polled", blocked: null, organs: [], endpoint: null };
+  const urls = [
+    "/api/anatomy/v1/organs/integrity",
+    "https://a-11-oy.com/api/a11oy/v1/organs/integrity",
+    EP.integrity,
+  ];
+  let last = "unreachable";
+  for (const url of urls) {
+    try {
+      const r = await fetch(url, { cache: "no-store", mode: url.startsWith("/") ? "same-origin" : "cors" });
+      if (!r.ok) { last = "HTTP " + r.status; continue; }
+      const j = await r.json();
+      const ev = j.body || j;
+      rec.status = STATUS.LIVE;
+      rec.blocked = !!ev.blocked;
+      rec.organs = ev.organs || [];
+      rec.endpoint = url;
+      rec.detail = (ev.live_count || 0) + "/5 LIVE · " + (ev.reason || "ok") +
+        " · energy UNAVAILABLE · Conjecture 1 OPEN";
+      last = null;
+      break;
+    } catch (e) {
+      last = (e && e.message) ? e.message : String(e);
+    }
+  }
+  if (last) {
+    rec.status = STATUS.UNREACHABLE;
+    rec.detail = "organ-integrity UNAVAILABLE — " + last;
+  }
+  if (typeof window !== "undefined") window.__szlOrganIntegrity = rec;
+  const el = document.getElementById("integrity-strip");
+  if (el) {
+    el.dataset.state = rec.status;
+    el.textContent = rec.detail;
+  }
+  return rec;
+}
+if (typeof window !== "undefined") {
+  window.probeOrganIntegrity = probeOrganIntegrity;
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", () => { probeOrganIntegrity(); });
+  } else {
+    probeOrganIntegrity();
+  }
+}

living_runtime.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Unified Python runtime for SZL Living Anatomy + YACHAY Second Brain.
+
+The existing Anatomy server remains the transport, evidence, receipt, and static
+rendering authority. This module extends it in-process with a source-bound,
+handles-only Second Brain organ and makes the combined body the Docker entry
+point. No reverse proxy, second process, model inference, private graph, or
+write authority is introduced.
+"""
+from __future__ import annotations
+
+import functools
+import json
+from http.server import ThreadingHTTPServer
+from typing import Any
+from urllib.parse import parse_qs, urlsplit
+
+import server as anatomy_server
+from second_brain_runtime import PublicSecondBrain
+
+BRAIN = PublicSecondBrain()
+
+# Bind the new runtime and its source snapshot into the existing deterministic
+# Anatomy receipt before the first request can populate any receipt cache.
+_EXTRA_ARTIFACTS = (
+    "living_runtime.py",
+    "second_brain_runtime.py",
+    ".runtime/second-brain/manifest.json",
+    ".runtime/second-brain/brain-corpus.public.jsonl",
+    ".runtime/second-brain/source.json",
+)
+anatomy_server.ARTIFACT_PATHS = tuple(
+    dict.fromkeys((*anatomy_server.ARTIFACT_PATHS, *_EXTRA_ARTIFACTS))
+)
+
+_ORIGINAL_MANIFEST = anatomy_server._manifest
+_ORIGINAL_VERSION = anatomy_server._version_contract
+_ORIGINAL_EVIDENCE = anatomy_server._evidence_contract
+
+
+def _living_manifest() -> dict[str, Any]:
+    payload = _ORIGINAL_MANIFEST()
+    payload["service"] = "living-anatomy-space"
+    payload["purpose"] = (
+        "Read-only spatial evidence map with a source-bound YACHAY Second Brain organ."
+    )
+    payload["contract_version"] = "1.2.0"
+    endpoints = payload.setdefault("endpoints", {})
+    endpoints.update(
+        {
+            "living_health": "/api/anatomy/v1/living-health",
+            "brain_health": "/api/anatomy/v1/brain/health",
+            "brain_manifest": "/api/anatomy/v1/brain/manifest",
+            "brain_search": "/api/anatomy/v1/brain/search",
+            "brain_context": "/api/anatomy/v1/brain/context",
+        }
+    )
+    payload["organs"] = {
+        "brain": {
+            "name": "YACHAY",
+            "state": BRAIN.health()["state"],
+            "ready": BRAIN.ready,
+            "source_repository": BRAIN.health()["source_repository"],
+            "source_revision": BRAIN.source_revision,
+            "authority_state": "READ_ONLY",
+            "content_access": "HANDLES_ONLY",
+        }
+    }
+    payload.setdefault("limits", []).extend(
+        [
+            "Second Brain ranking is lexical relevance, never correctness.",
+            "The public projection contains handles only; the private graph is not present.",
+        ]
+    )
+    return payload
+
+
+def _living_version(force: bool = False) -> dict[str, Any]:
+    payload = _ORIGINAL_VERSION(force=force)
+    payload["contractVersion"] = "1.2.0"
+    payload["runtime"] = "living-anatomy+yachay"
+    payload["secondBrainSourceRevision"] = BRAIN.source_revision
+    payload["secondBrainEvidenceState"] = "MEASURED" if BRAIN.ready else "UNAVAILABLE"
+    return payload
+
+
+def _living_evidence(force: bool = False) -> dict[str, Any]:
+    payload = _ORIGINAL_EVIDENCE(force=force)
+    brain = BRAIN.health()
+    dependencies = payload.setdefault("dependencies", {})
+    dependencies["secondBrain"] = {
+        "ready": brain["ready"],
+        "state": brain["state"],
+        "sourceRepository": brain["source_repository"],
+        "sourceRevision": brain["source_revision"],
+        "chunkCount": brain["chunk_count"],
+        "verificationState": brain["verification_state"],
+        "authorityState": brain["authority_state"],
+        "details": "/api/anatomy/v1/brain/health",
+    }
+    runtime = payload.setdefault("runtime", {})
+    if not BRAIN.ready:
+        runtime["status"] = "DEGRADED"
+        runtime["ready"] = False
+        payload.setdefault("limitations", []).append(
+            "YACHAY Second Brain snapshot is unavailable; Living Anatomy remains transport-reachable but the integrated body is not ready."
+        )
+    return payload
+
+
+anatomy_server._manifest = _living_manifest
+anatomy_server._version_contract = _living_version
+anatomy_server._evidence_contract = _living_evidence
+
+if not any(
+    isinstance(item, dict) and item.get("id") == "anatomy.yachay-second-brain"
+    for item in anatomy_server.CAPABILITIES
+):
+    anatomy_server.CAPABILITIES.append(
+        {
+            "id": "anatomy.yachay-second-brain",
+            "name": "YACHAY source-bound Second Brain",
+            "purpose": (
+                "Ground the Living Anatomy brain organ in the public 575-chunk "
+                "Second Brain projection without exposing corpus text or private nodes."
+            ),
+            "try": {
+                "method": "GET",
+                "path": "/api/anatomy/v1/brain/search?q=governed%20receipts&k=6",
+                "action": "Retrieve source-bound public handles.",
+            },
+            "evidence": {
+                "state": "MEASURED" if BRAIN.ready else "UNAVAILABLE",
+                "basis": (
+                    "Deployment-pinned GitHub revision, manifest digest, corpus digest, "
+                    "per-row SHA-256 checks, and exact chunk count."
+                ),
+                "source_revision": BRAIN.source_revision,
+                "chunk_count": BRAIN.health()["chunk_count"],
+            },
+            "limits": [
+                "Lexical overlap is not correctness.",
+                "No corpus text is returned by the retrieval API.",
+                "No private graph node is bundled or queried.",
+                "No write or training authority is granted.",
+            ],
+            "reproduce": {
+                "steps": [
+                    "GET /api/anatomy/v1/brain/health",
+                    "Compare source_revision with szl-holdings/szl-second-brain.",
+                    "GET /api/anatomy/v1/brain/manifest and inspect the snapshot receipt.",
+                    "Run a search and verify every result is a handle with a SHA-256 pointer.",
+                ]
+            },
+            "authority_state": "READ_ONLY",
+            "formula_refs": ["F1", "F22"],
+            "provenance": [
+                "https://github.com/szl-holdings/szl-second-brain",
+                "https://huggingface.co/datasets/SZLHOLDINGS/szl-second-brain-inrepo",
+            ],
+        }
+    )
+
+
+class LivingAnatomyHandler(anatomy_server.HardenedHandler):
+    """Add the YACHAY API while preserving every existing Anatomy route."""
+
+    def _brain_headers(self, evidence_state: str) -> dict[str, str]:
+        return {
+            "X-SZL-Brain-State": (
+                "SOURCE_BOUND_PUBLIC_PROJECTION" if BRAIN.ready else "UNAVAILABLE"
+            ),
+            "X-SZL-Brain-Authority": "READ_ONLY",
+            "X-SZL-Brain-Evidence": evidence_state,
+        }
+
+    @staticmethod
+    def _bounded_k(value: Any) -> int:
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            parsed = 6
+        return max(1, min(parsed, 12))
+
+    def _read_json_body(self, maximum: int = 32_768) -> tuple[int, dict[str, Any] | None]:
+        try:
+            length = int(self.headers.get("Content-Length", "0"))
+        except ValueError:
+            length = 0
+        if length <= 0 or length > maximum:
+            return 400, None
+        try:
+            payload = json.loads(self.rfile.read(length))
+        except Exception:
+            return 400, None
+        if not isinstance(payload, dict):
+            return 400, None
+        return 200, payload
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urlsplit(self.path)
+        path = parsed.path
+        query = parse_qs(parsed.query)
+        if path == "/api/anatomy/v1/living-health":
+            if query.get("refresh") == ["1"]:
+                BRAIN.reload()
+            brain = BRAIN.health()
+            payload = {
+                "schema": "szl.living-anatomy.health/v1",
+                "status": "ok" if brain["ready"] else "degraded",
+                "ready": bool(brain["ready"]),
+                "service": "living-anatomy-space",
+                "transport_state": "REACHABLE",
+                "evidence_state": "MEASURED" if brain["ready"] else "UNAVAILABLE",
+                "verification_state": "STRUCTURAL_ONLY" if brain["ready"] else "FAILED",
+                "authority_state": "READ_ONLY",
+                "organs": {
+                    "anatomy": {
+                        "ready": True,
+                        "state": "REACHABLE",
+                        "contract": "/healthz",
+                    },
+                    "brain": {
+                        "ready": brain["ready"],
+                        "state": brain["state"],
+                        "source_revision": brain["source_revision"],
+                        "chunk_count": brain["chunk_count"],
+                        "contract": "/api/anatomy/v1/brain/health",
+                    },
+                },
+                "note": (
+                    "Combined readiness requires both the Anatomy transport and the "
+                    "source-bound public Second Brain projection."
+                ),
+            }
+            evidence = str(payload["evidence_state"])
+            self._send_json(
+                payload,
+                status=200 if brain["ready"] else 503,
+                evidence_state=evidence,
+                extra_headers=self._brain_headers(evidence),
+            )
+            return
+        if path == "/api/anatomy/v1/brain/health":
+            if query.get("refresh") == ["1"]:
+                BRAIN.reload()
+            payload = BRAIN.health()
+            evidence = str(payload["evidence_state"])
+            self._send_json(
+                payload,
+                status=200 if payload["ready"] else 503,
+                evidence_state=evidence,
+                extra_headers=self._brain_headers(evidence),
+            )
+            return
+        if path == "/api/anatomy/v1/brain/manifest":
+            payload = BRAIN.manifest()
+            evidence = "MEASURED" if payload["ready"] else "UNAVAILABLE"
+            self._send_json(
+                payload,
+                status=200 if payload["ready"] else 503,
+                evidence_state=evidence,
+                extra_headers=self._brain_headers(evidence),
+            )
+            return
+        if path in (
+            "/api/anatomy/v1/brain/search",
+            "/api/anatomy/v1/brain/query",
+        ):
+            phrase = (query.get("q") or query.get("query") or [""])[0]
+            k = self._bounded_k((query.get("k") or [6])[0])
+            payload = BRAIN.search(phrase, k=k)
+            evidence = "COMPUTED" if payload["ready"] else "UNAVAILABLE"
+            self._send_json(
+                payload,
+                status=200 if payload["ready"] else 503,
+                evidence_state=evidence,
+                extra_headers=self._brain_headers(evidence),
+            )
+            return
+        if path == "/api/anatomy/v1/brain/context":
+            phrase = (query.get("q") or query.get("query") or [""])[0]
+            k = self._bounded_k((query.get("k") or [6])[0])
+            payload = BRAIN.context(phrase, k=k)
+            evidence = "COMPUTED" if payload["ready"] else "UNAVAILABLE"
+            self._send_json(
+                payload,
+                status=200 if payload["ready"] else 503,
+                evidence_state=evidence,
+                extra_headers=self._brain_headers(evidence),
+            )
+            return
+        super().do_GET()
+
+    def do_POST(self) -> None:  # noqa: N802
+        path = urlsplit(self.path).path
+        if path not in (
+            "/api/anatomy/v1/brain/search",
+            "/api/anatomy/v1/brain/query",
+            "/api/anatomy/v1/brain/context",
+        ):
+            super().do_POST()
+            return
+        status, body = self._read_json_body()
+        if body is None:
+            self._send_json(
+                {
+                    "error": "invalid_body",
+                    "detail": "JSON object required; maximum 32,768 bytes.",
+                },
+                status=status,
+                evidence_state="UNAVAILABLE",
+                extra_headers=self._brain_headers("UNAVAILABLE"),
+            )
+            return
+        phrase = str(body.get("query") or body.get("q") or "")
+        k = self._bounded_k(body.get("k", 6))
+        payload = (
+            BRAIN.context(phrase, k=k)
+            if path.endswith("/context")
+            else BRAIN.search(phrase, k=k)
+        )
+        evidence = "COMPUTED" if payload["ready"] else "UNAVAILABLE"
+        self._send_json(
+            payload,
+            status=200 if payload["ready"] else 503,
+            evidence_state=evidence,
+            extra_headers=self._brain_headers(evidence),
+        )
+
+
+def make_server(
+    host: str = "0.0.0.0",
+    port: int = anatomy_server.PORT,
+) -> ThreadingHTTPServer:
+    handler = functools.partial(
+        LivingAnatomyHandler,
+        directory=str(anatomy_server.DIRECTORY),
+    )
+    return ThreadingHTTPServer((host, port), handler)
+
+
+if __name__ == "__main__":
+    httpd = make_server()
+    print(
+        "Serving SZL Living Anatomy + YACHAY Second Brain "
+        f"from {anatomy_server.DIRECTORY} on 0.0.0.0:{anatomy_server.PORT}; "
+        f"brain_ready={BRAIN.ready} source={BRAIN.source_revision}",
+        flush=True,
+    )
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        httpd.server_close()

organ_integrity.py

@@ -0,0 +1,602 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+# Signed-off-by: Lutar, Stephen P. <stephenlutar2@gmail.com>
+"""Five-organ fail-closed integrity kernel.
+
+Stdlib only. Real SHA-256. Advisory Λ. Energy UNAVAILABLE. Never a fabricated
+joule. Locked-proven stays exactly 8. Λ uniqueness is Conjecture 1 OPEN.
+proven_trust is False.
+
+This is the replayable contract the 3D atlas (szl-holdings/anatomy) maps and
+the KHIPU Space (SZLHOLDINGS/szl-khipu) runs in NumPy. This surface is the
+same fail-closed body, hashed with hashlib.sha256 — not a Three.js rehost,
+not a joule, not a theorem.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import sys
+from datetime import datetime, timezone
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Iterable, Mapping, Sequence
+from urllib.parse import parse_qs, urlparse
+
+DOCTRINE = "v11 LOCKED"
+KERNEL_COMMIT = "c7c0ba17"
+LOCKED_EIGHT = ("F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22")
+YUYAY_AXES = (
+    "moralGrounding",
+    "measurabilityHonesty",
+    "empiricalGrounding",
+    "logicalConsistency",
+    "sourceTransparency",
+    "reproducibility",
+    "licenseHygiene",
+    "scopeDiscipline",
+    "claimCalibration",
+    "evalAwareness",
+    "deceptionKeywords",
+    "conflictingDirectives",
+    "reversalDirective",
+)
+YUYAY_FLOORS = (0.95, 0.95) + (0.90,) * 11
+CONJECTURE_1 = (
+    "Any two aggregators satisfying A1–A4 agree on every input. OPEN (sorry). "
+    "Unconditional uniqueness under kernel A1–A5 is machine-checked FALSE."
+)
+WILLAY_NOTE = (
+    "Refusals are tamper-EVIDENT, not tamper-proof. Auditable rules. "
+    "Trust ceiling 0.97. WILLAY is conscience, not a sixth proven organ."
+)
+ZERO = "0" * 64
+CHAIN_OPS = ("anatomy.brain", "anatomy.heart", "anatomy.skeleton")
+ORGAN_SPEC = (
+    {
+        "id": "brain",
+        "name": "BRAIN",
+        "quechua": "YACHAY",
+        "formulas": ("F1",),
+        "role": "read-only reasoning cortex — never holds write authority",
+    },
+    {
+        "id": "heart",
+        "name": "HEART",
+        "quechua": "YUYAY",
+        "formulas": ("F4", "F11"),
+        "role": "13-axis conjunctive critique gate — advisory Λ",
+    },
+    {
+        "id": "circulatory",
+        "name": "CIRCULATORY",
+        "quechua": "YAWAR",
+        "formulas": ("F7", "F22"),
+        "role": "append-only receipt bus — SHA-256",
+    },
+    {
+        "id": "nervous",
+        "name": "NERVOUS",
+        "quechua": "OTel",
+        "formulas": ("F12",),
+        "role": "telemetry spine — energy UNAVAILABLE",
+    },
+    {
+        "id": "skeleton",
+        "name": "SKELETON",
+        "quechua": "Khipu",
+        "formulas": ("F18", "F19"),
+        "role": "locked-8 formula spine — CHECKED ≠ Lean PROVEN",
+    },
+)
+
+proven_trust = False
+
+
+def _sha256_hex(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def wgm(xs: Sequence[float], ws: Sequence[float]) -> float:
+    if len(xs) != len(ws) or not xs:
+        return 0.0
+    if any((not math.isfinite(x)) or x <= 0.0 for x in xs):
+        return 0.0
+    if any((not math.isfinite(w)) or w < 0.0 for w in ws):
+        return 0.0
+    if abs(sum(ws) - 1.0) >= 1e-9:
+        return 0.0
+    value = math.exp(sum(w * math.log(x) for x, w in zip(xs, ws)))
+    return value if math.isfinite(value) else 0.0
+
+
+def evaluate_lambda(axes: Sequence[float]) -> dict[str, Any]:
+    n = len(axes)
+    weights = tuple(1.0 / n for _ in range(n)) if n else ()
+    value = wgm(axes, weights)
+    xv = list(axes)
+    a1 = True
+    for i, x in enumerate(xv):
+        if x >= 1.0:
+            continue
+        y = xv[:]
+        y[i] = min(1.0, x + 0.05)
+        if wgm(y, weights) + 1e-12 < value:
+            a1 = False
+            break
+    c = 0.5
+    a2 = abs(wgm([x * c for x in xv], weights) - c * value) <= 1e-9 * max(1.0, abs(c * value))
+    a3 = abs(wgm([0.7] * n, weights) - 0.7) <= 1e-9 if n else True
+    a4 = (not xv) or value <= max(xv) + 1e-12
+    a5 = True
+    if n >= 2:
+        a5 = abs(wgm(list(reversed(xv)), list(reversed(weights))) - value) <= 1e-9
+    axioms = [
+        {"id": "A1", "ok": a1, "detail": "monotone"},
+        {"id": "A2", "ok": a2, "detail": "homogeneous"},
+        {"id": "A3", "ok": a3, "detail": "Egyptian-exact"},
+        {"id": "A4", "ok": a4, "detail": "bounded-by-max"},
+        {"id": "A5", "ok": a5, "detail": "permutation-invariant"},
+    ]
+    failed = next((a for a in axioms if not a["ok"]), None)
+    blocked = value == 0.0 or failed is not None
+    if blocked:
+        reason = "zero-routed or non-finite axis" if value == 0.0 else f"axiom {failed['id']} failed"
+    else:
+        reason = "advisory pass — uniqueness remains Conjecture 1 OPEN"
+    return {"value": float(value), "blocked": bool(blocked), "reason": reason, "axioms": axioms}
+
+
+def yawar_chain(seed: int, tamper: bool) -> dict[str, Any]:
+    hops: list[dict[str, Any]] = []
+    prev = ZERO
+    for seq, op in enumerate(CHAIN_OPS):
+        material = f"{seq}|{op}|{prev}|{int(seed)}"
+        digest = _sha256_hex(material)
+        hops.append({"seq": seq, "op": op, "prev": prev, "digest": digest, "alg": "SHA-256"})
+        prev = digest
+    if tamper and len(hops) > 1:
+        hops[1] = dict(hops[1])
+        hops[1]["prev"] = "deadbeef" + hops[1]["prev"][8:]
+    walk = ZERO
+    ok = True
+    brk: int | None = None
+    for hop in hops:
+        expect = _sha256_hex(f"{hop['seq']}|{hop['op']}|{hop['prev']}|{int(seed)}")
+        if hop["prev"] != walk or expect != hop["digest"]:
+            ok = False
+            brk = int(hop["seq"])
+            break
+        walk = hop["digest"]
+    return {
+        "hops": hops,
+        "ok": ok,
+        "head": hops[-1]["digest"] if hops else ZERO,
+        "depth": len(hops),
+        "break_at": brk,
+        "alg": "SHA-256",
+    }
+
+
+def canal_leak(leak: bool) -> float:
+    """Deterministic canal-partition silhouette.
+
+    Tokens 0..11 assigned to canal i % 3. Cross-canal mass is zero unless a
+    leak is requested. This is the fail-closed rule, not NumPy YARQA.
+    MEASURED YARQA lives on SZLHOLDINGS/szl-khipu.
+    """
+    return 1.0 if leak else 0.0
+
+
+def _organ(
+    id_: str,
+    name: str,
+    quechua: str,
+    formulas: tuple[str, ...],
+    status: str,
+    honesty: str,
+    detail: str,
+    metric: float,
+) -> dict[str, Any]:
+    return {
+        "id": id_,
+        "name": name,
+        "quechua": quechua,
+        "formulas": list(formulas),
+        "status": status,
+        "honesty": honesty,
+        "detail": detail,
+        "metric": float(metric),
+    }
+
+
+def evaluate_anatomy(
+    *,
+    zero_heart: bool = False,
+    leak_canal: bool = False,
+    tamper_chain: bool = False,
+    fabricate_joule: bool = False,
+    break_skeleton: bool = False,
+    willay_fire: bool = False,
+    seed: int = 11,
+) -> dict[str, Any]:
+    if proven_trust is True:
+        raise RuntimeError("refusing proven_trust true")
+
+    axes = list(YUYAY_FLOORS)
+    if zero_heart:
+        axes[0] = 0.0
+    heart = evaluate_lambda(axes)
+    heart_down = bool(heart["blocked"])
+
+    chain = yawar_chain(int(seed), bool(tamper_chain))
+    yawar_down = not bool(chain["ok"])
+
+    leaked = canal_leak(bool(leak_canal))
+    brain_down = leaked > 1e-9
+
+    nervous_down = bool(fabricate_joule)
+
+    rows = [
+        {"id": fid, "ok": not (break_skeleton and fid == "F18")}
+        for fid in LOCKED_EIGHT
+    ]
+    skeleton_pass = sum(1 for r in rows if r["ok"])
+    skeleton_down = skeleton_pass < len(rows)
+
+    organs = [
+        _organ(
+            "brain",
+            "BRAIN",
+            "YACHAY",
+            ("F1",),
+            "DOWN" if brain_down else "LIVE",
+            "LIVE",
+            (
+                f"cross-canal leak {leaked:.3e} — YACHAY cannot reason across a broken partition"
+                if brain_down
+                else (
+                    "read-only cortex · canal-partition silhouette leak 0 · "
+                    "MEASURED YARQA is the KHIPU Space"
+                )
+            ),
+            leaked,
+        ),
+        _organ(
+            "heart",
+            "HEART",
+            "YUYAY",
+            ("F4", "F11"),
+            "DOWN" if heart_down else "LIVE",
+            "ADVISORY",
+            (
+                f"Λ {float(heart['value']):.4f} · {heart['reason']}"
+                if heart_down
+                else f"Λ {float(heart['value']):.4f} · advisory · Conjecture 1 OPEN"
+            ),
+            float(heart["value"]),
+        ),
+        _organ(
+            "circulatory",
+            "CIRCULATORY",
+            "YAWAR",
+            ("F7", "F22"),
+            "DOWN" if yawar_down else "LIVE",
+            "LIVE",
+            (
+                f"chain break at {chain['break_at']} — prev pointer does not walk. Fail closed."
+                if yawar_down
+                else f"3-hop SHA-256 · depth {chain['depth']} · head {chain['head'][:16]}"
+            ),
+            0.0 if chain["ok"] else 1.0,
+        ),
+        _organ(
+            "nervous",
+            "NERVOUS",
+            "OTel",
+            ("F12",),
+            "DOWN" if nervous_down else "LIVE",
+            "UNAVAILABLE",
+            (
+                "fabricated joule refused — energy stays UNAVAILABLE"
+                if nervous_down
+                else "loop-tax silhouette · energy UNAVAILABLE · never a fabricated joule"
+            ),
+            1.0 if nervous_down else 0.0,
+        ),
+        _organ(
+            "skeleton",
+            "SKELETON",
+            "Khipu",
+            ("F18", "F19"),
+            "DOWN" if skeleton_down else "LIVE",
+            "ADVISORY",
+            (
+                f"locked-8 silhouettes {skeleton_pass}/{len(rows)} — a sorry cannot be painted green"
+                if skeleton_down
+                else (
+                    f"locked-8 silhouettes {skeleton_pass}/{len(rows)} · "
+                    f"CHECKED ≠ Lean PROVEN @ {KERNEL_COMMIT}"
+                )
+            ),
+            float(skeleton_pass),
+        ),
+    ]
+
+    live_count = sum(1 for o in organs if o["status"] == "LIVE")
+    organ_down = any(o["status"] == "DOWN" for o in organs)
+    blocked = organ_down or bool(willay_fire)
+    if willay_fire:
+        reason = (
+            "WILLAY conscience veto — governance bypass refused "
+            "(tamper-EVIDENT, not tamper-proof)"
+        )
+    elif organ_down:
+        down = ", ".join(o["name"] for o in organs if o["status"] == "DOWN")
+        reason = f"organ integrity FAIL · {down} DOWN · fail closed"
+    else:
+        reason = (
+            f"organ integrity {live_count}/5 LIVE · Λ advisory · "
+            "energy UNAVAILABLE · Conjecture 1 OPEN"
+        )
+
+    return {
+        "organs": organs,
+        "live_count": int(live_count),
+        "blocked": bool(blocked),
+        "verdict": "BLOCKED" if blocked else "ADVISORY_BODY",
+        "willay": {
+            "refused": bool(willay_fire),
+            "category": "bypass" if willay_fire else "none",
+            "note": WILLAY_NOTE,
+        },
+        "energy": "UNAVAILABLE",
+        "energy_j": None,
+        "lambda_advisory": True,
+        "conjecture_1": "OPEN",
+        "conjecture_1_statement": CONJECTURE_1,
+        "locked_proven": 8,
+        "locked_ids": list(LOCKED_EIGHT),
+        "kernel_commit": KERNEL_COMMIT,
+        "doctrine": DOCTRINE,
+        "chain_head": chain["head"],
+        "chain_ok": bool(chain["ok"]),
+        "chain_alg": "SHA-256",
+        "chain": chain,
+        "lambda": heart,
+        "proven_trust": False,
+        "trust_ceiling": 0.97,
+        "reason": reason,
+        "seed": int(seed),
+        "tamper": {
+            "zero_heart": bool(zero_heart),
+            "leak_canal": bool(leak_canal),
+            "tamper_chain": bool(tamper_chain),
+            "fabricate_joule": bool(fabricate_joule),
+            "break_skeleton": bool(break_skeleton),
+            "willay_fire": bool(willay_fire),
+        },
+        "not_a_rehost": (
+            "szl-holdings/anatomy 3D atlas is SLSA L1 static viz — "
+            "this kernel is the integrity check"
+        ),
+        "checked_at": _now(),
+    }
+
+
+def envelope(ev: Mapping[str, Any]) -> dict[str, Any]:
+    payload = json.dumps(ev, sort_keys=True, separators=(",", ":"), default=str)
+    return {
+        "ok": True,
+        "surface": "szl-organ-integrity",
+        "receipt_sha256": _sha256_hex(payload),
+        "signing": "STRUCTURAL-ONLY — no key on this surface; tamper-EVIDENT hash, not a signature",
+        "body": dict(ev),
+    }
+
+
+def parse_flags(src: Mapping[str, Any] | None) -> dict[str, Any]:
+    src = src or {}
+
+    def flag(name: str) -> bool:
+        v = src.get(name, False)
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, (int, float)):
+            return int(v) == 1
+        if isinstance(v, str):
+            return v.strip().lower() in {"1", "true", "yes", "on"}
+        if isinstance(v, list) and v:
+            return flag(v[0])
+        return False
+
+    seed = src.get("seed", 11)
+    if isinstance(seed, list) and seed:
+        seed = seed[0]
+    try:
+        seed_i = int(seed)
+    except (TypeError, ValueError):
+        seed_i = 11
+    return {
+        "zero_heart": flag("zero_heart"),
+        "leak_canal": flag("leak_canal"),
+        "tamper_chain": flag("tamper_chain"),
+        "fabricate_joule": flag("fabricate_joule"),
+        "break_skeleton": flag("break_skeleton"),
+        "willay_fire": flag("willay_fire"),
+        "seed": seed_i,
+    }
+
+
+def selftest() -> dict[str, Any]:
+    healthy = evaluate_anatomy(seed=11)
+    assert healthy["live_count"] == 5, healthy["reason"]
+    assert healthy["blocked"] is False
+    assert healthy["energy"] == "UNAVAILABLE"
+    assert healthy["energy_j"] is None
+    assert healthy["proven_trust"] is False
+    assert healthy["locked_proven"] == 8
+    assert healthy["lambda_advisory"] is True
+    assert healthy["chain"]["alg"] == "SHA-256"
+    assert len(healthy["chain"]["head"]) == 64
+
+    z = evaluate_anatomy(zero_heart=True, seed=11)
+    assert z["blocked"] is True
+    assert z["organs"][1]["status"] == "DOWN"
+    assert z["organs"][1]["metric"] == 0.0
+
+    t = evaluate_anatomy(tamper_chain=True, seed=11)
+    assert t["blocked"] is True
+    assert t["chain_ok"] is False
+    assert t["organs"][2]["status"] == "DOWN"
+
+    j = evaluate_anatomy(fabricate_joule=True, seed=11)
+    assert j["blocked"] is True
+    assert j["organs"][3]["status"] == "DOWN"
+    assert j["energy_j"] is None
+
+    s = evaluate_anatomy(break_skeleton=True, seed=11)
+    assert s["blocked"] is True
+    assert s["organs"][4]["metric"] == 7
+
+    w = evaluate_anatomy(willay_fire=True, seed=11)
+    assert w["blocked"] is True
+    assert w["willay"]["refused"] is True
+    assert w["live_count"] == 5
+
+    l = evaluate_anatomy(leak_canal=True, seed=11)
+    assert l["blocked"] is True
+    assert l["organs"][0]["status"] == "DOWN"
+
+    return {"ok": True, "cases": 7, "healthy_head": healthy["chain_head"]}
+
+
+def _json_bytes(obj: Any, status: int = 200) -> tuple[int, bytes, str]:
+    raw = json.dumps(obj, indent=2, default=str).encode("utf-8")
+    return status, raw, "application/json; charset=utf-8"
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "szl-organ-integrity/1.0"
+
+    def log_message(self, fmt: str, *args: Any) -> None:  # noqa: A003
+        sys.stderr.write("%s - %s\n" % (self.address_string(), fmt % args))
+
+    def _cors(self) -> None:
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "content-type")
+        self.send_header("Cache-Control", "no-store")
+
+    def do_OPTIONS(self) -> None:  # noqa: N802
+        self.send_response(204)
+        self._cors()
+        self.end_headers()
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urlparse(self.path)
+        path = parsed.path.rstrip("/") or "/"
+        qs = parse_qs(parsed.query)
+        if path in {"/healthz", "/readyz"}:
+            self._send(*_json_bytes({"ok": True, "energy": "UNAVAILABLE", "proven_trust": False}))
+            return
+        if path in {
+            "/api/organs/integrity",
+            "/api/a11oy/v1/organs/integrity",
+            "/v1/organs/integrity",
+        }:
+            flags = parse_flags(qs)
+            body = envelope(evaluate_anatomy(**flags))
+            self._send(*_json_bytes(body))
+            return
+        if path in {"/", "/index.html", "/organs/integrity"}:
+            html = _index_html()
+            self._send(200, html.encode("utf-8"), "text/html; charset=utf-8")
+            return
+        self._send(*_json_bytes({"ok": False, "error": "not found", "path": path}, 404))
+
+    def do_POST(self) -> None:  # noqa: N802
+        parsed = urlparse(self.path)
+        path = parsed.path.rstrip("/") or "/"
+        if path not in {
+            "/api/organs/integrity",
+            "/api/a11oy/v1/organs/integrity",
+            "/v1/organs/integrity",
+        }:
+            self._send(*_json_bytes({"ok": False, "error": "not found"}, 404))
+            return
+        length = int(self.headers.get("Content-Length") or 0)
+        raw = self.rfile.read(max(0, min(length, 1_000_000))) if length else b"{}"
+        try:
+            data = json.loads(raw.decode("utf-8") or "{}")
+        except json.JSONDecodeError:
+            data = {}
+        if not isinstance(data, dict):
+            data = {}
+        flags = parse_flags(data)
+        body = envelope(evaluate_anatomy(**flags))
+        self._send(*_json_bytes(body))
+
+    def _send(self, status: int, raw: bytes, ctype: str) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(raw)))
+        self._cors()
+        self.end_headers()
+        self.wfile.write(raw)
+
+
+def _index_html() -> str:
+    from pathlib import Path
+
+    here = Path(__file__).resolve().parent
+    for candidate in (here / "index.html", here / "site" / "index.html"):
+        if candidate.is_file():
+            return candidate.read_text(encoding="utf-8")
+    return (
+        "<!doctype html><meta charset=utf-8><title>organ integrity</title>"
+        "<p>kernel live. POST /api/organs/integrity</p>"
+    )
+
+
+def serve(host: str = "0.0.0.0", port: int = 7860) -> None:
+    httpd = ThreadingHTTPServer((host, port), Handler)
+    print(f"[szl-organ-integrity] {host}:{port} · SHA-256 · energy UNAVAILABLE", file=sys.stderr)
+    httpd.serve_forever()
+
+
+def main(argv: Iterable[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="Five-organ fail-closed integrity kernel")
+    p.add_argument("--serve", action="store_true")
+    p.add_argument("--host", default="0.0.0.0")
+    p.add_argument("--port", type=int, default=7860)
+    p.add_argument("--tamper", nargs="*", default=[], help="zero_heart leak_canal tamper_chain fabricate_joule break_skeleton willay_fire")
+    p.add_argument("--seed", type=int, default=11)
+    args = p.parse_args(list(argv) if argv is not None else None)
+    if args.serve:
+        serve(args.host, args.port)
+        return 0
+    flags = {k: (k in set(args.tamper)) for k in (
+        "zero_heart",
+        "leak_canal",
+        "tamper_chain",
+        "fabricate_joule",
+        "break_skeleton",
+        "willay_fire",
+    )}
+    if args.tamper:
+        print(json.dumps(envelope(evaluate_anatomy(seed=args.seed, **flags)), indent=2))
+        return 0
+    result = selftest()
+    print(json.dumps(result, indent=2))
+    return 0 if result.get("ok") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qa_cockpit.mjs

@@ -0,0 +1,118 @@
+// QA — Covenant Cockpit v1 (headless, no browser needed).
+// Loads the REAL covenant-cockpit.js pure logic + the bundled receipts.sample.json
+// and asserts the honest invariants that back the cockpit:
+//   1. receipts normalize from the szl-receipt in-toto bundle (no fabricated nodes)
+//   2. the provenance graph binds every decision -> Λ-gate + Lean proof + energy + BFT witnesses
+//   3. the verify badge is GENUINE: signed -> verified, unsigned -> UNAVAILABLE, tamper -> failed
+//   4. energy is measured joules OR honest UNAVAILABLE (never fabricated)
+//   5. empty input -> honest empty graph (zero nodes), never a decorative fallback
+//
+// Run:  node qa_cockpit.mjs
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const ROOT = path.dirname(fileURLToPath(import.meta.url));
+
+// covenant-cockpit.js is a browser ES module (export default). Load its pure
+// logic here by stripping the two `export` lines and evaluating (it has NO
+// top-level `import`, and guards all `window` use), then grabbing the object.
+async function loadModule() {
+  // covenant-cockpit.js is a valid browser ES module (export default + guarded
+  // `window`). Load it in node by copying to a temp .mjs and importing it — no
+  // fragile source-stripping, and the real module code is exercised verbatim.
+  const src = fs.readFileSync(path.join(ROOT, "covenant-cockpit.js"), "utf8");
+  // Write the temp module into a per-run PRIVATE directory (mkdtemp: random
+  // name, mode 0700) instead of a predictable path in the shared temp dir, so it
+  // cannot be pre-created, swapped, or read by another local user before we
+  // import it (CodeQL js/insecure-temporary-file).
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "cc-qa-"));
+  const tmp = path.join(tmpDir, "covenant-cockpit.mjs");
+  fs.writeFileSync(tmp, src);
+  try {
+    const mod = await import(pathToFileURL(tmp).href);
+    return mod.default;
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* best-effort cleanup */ }
+  }
+}
+
+let failures = 0;
+function ok(cond, msg) {
+  console.log((cond ? "  ✓ " : "  ✗ ") + msg);
+  if (!cond) failures++;
+}
+function section(t) { console.log("\n== " + t + " =="); }
+
+const bundle = JSON.parse(fs.readFileSync(path.join(ROOT, "receipts.sample.json"), "utf8"));
+
+(async () => {
+  const CC = await loadModule();
+  section("normalize the szl-receipt in-toto bundle");
+  const { receipts, cosignPub } = CC.normalizeBundle(bundle);
+  ok(receipts.length === 4, `normalizes 4 receipts (got ${receipts.length})`);
+  ok(!!cosignPub && /BEGIN PUBLIC KEY/.test(cosignPub), "cosign public key present for offline verify");
+  ok(receipts.every((r) => r.body && r.body.model_id && r.body.policy_id && r.body.lean_theorem),
+     "every receipt decodes model_id + policy_id + lean_theorem");
+
+  section("build the provenance graph (pure)");
+  const g = CC.buildGraph(receipts);
+  ok(g.stats.decisions === 4, `4 decision nodes (got ${g.stats.decisions})`);
+  ok(g.stats.gates >= 1, `≥1 Λ-gate node (got ${g.stats.gates})`);
+  ok(g.stats.proofs >= 1, `≥1 Lean proof node (got ${g.stats.proofs})`);
+  ok(g.stats.witnesses >= 1, `≥1 BFT witness node (got ${g.stats.witnesses})`);
+  ok(g.edges.length > 0, `edges present (got ${g.edges.length})`);
+  // every decision must bind to a gate, a proof, an energy node, and >=1 witness
+  const decNodes = g.nodes.filter((n) => n.kind === "decision");
+  const edgesFrom = (id, kind) => g.edges.filter((e) => e.from === id && kindOf(g, e.to) === kind);
+  const kindOf = (gr, id) => (gr.nodes.find((n) => n.id === id) || {}).kind;
+  let bound = true;
+  for (const d of decNodes) {
+    const hasGate = edgesFrom(d.id, "gate").length >= 1;
+    const hasProof = edgesFrom(d.id, "proof").length >= 1;
+    const hasEnergy = edgesFrom(d.id, "energy").length >= 1;
+    const hasWitness = edgesFrom(d.id, "cosigned" /*ignored*/) ; // recompute below
+    const wit = g.edges.filter((e) => e.from === d.id && kindOf(g, e.to) === "witness").length;
+    if (!(hasGate && hasProof && hasEnergy && wit >= 1)) bound = false;
+  }
+  ok(bound, "every decision binds → Λ-gate + Lean proof + energy + ≥1 BFT witness");
+  ok(g.nodes.every((n) => Array.isArray(n.pos) && n.pos.length === 3 && n.pos.every(Number.isFinite)),
+     "every node has a finite 3D position (renderable)");
+
+  section("energy is measured joules OR honest UNAVAILABLE");
+  ok(g.stats.energyMeasured === 2 && g.stats.energyUnavailable === 2,
+     `2 measured / 2 UNAVAILABLE energy nodes (got ${g.stats.energyMeasured}/${g.stats.energyUnavailable})`);
+  const eNodes = g.nodes.filter((n) => n.kind === "energy");
+  ok(eNodes.every((n) => n.meta.measured ? typeof n.meta.joules === "number" : n.meta.joules === null),
+     "measured energy carries a real joule value; unavailable carries null (never fabricated)");
+
+  section("verify badge is GENUINE (WebCrypto ECDSA-P256 over DSSE PAE)");
+  const key = await CC.importCosign(cosignPub);
+  const results = [];
+  for (const r of receipts) results.push(await CC.verifyEnvelope(r.envelope, key));
+  const verified = results.filter((v) => v.status === CC.VERIFY.VERIFIED).length;
+  const unavail = results.filter((v) => v.status === CC.VERIFY.UNAVAILABLE).length;
+  ok(verified === 3, `3 signed receipts VERIFY (got ${verified})`);
+  ok(unavail === 1, `1 unsigned receipt is honest UNAVAILABLE (got ${unavail})`);
+
+  // tamper: flip the verdict on a signed receipt -> must FAIL (never a fake pass)
+  const signedIdx = receipts.findIndex((r) => r.envelope.signed === true);
+  const t = JSON.parse(JSON.stringify(receipts[signedIdx].envelope));
+  const body = JSON.parse(Buffer.from(t.payload, "base64").toString("utf8"));
+  body.verdict = body.verdict === "allow" ? "block" : "allow";
+  const keys = Object.keys(body).sort();
+  const canon = JSON.stringify(body, keys);
+  t.payload = Buffer.from(canon, "utf8").toString("base64");
+  const vt = await CC.verifyEnvelope(t, key);
+  ok(vt.status === CC.VERIFY.FAILED, `tampered receipt FAILS verify (got ${vt.status})`);
+
+  section("honest empty state — never fabricate nodes");
+  const empty = CC.buildGraph([]);
+  ok(empty.nodes.length === 0 && empty.edges.length === 0, "empty input → zero nodes, zero edges");
+  const bad = CC.normalizeBundle({ receipts: [{ id: "x" }, { junk: true }] });
+  ok(bad.receipts.length === 0, "entries without a payload are skipped, not turned into fake nodes");
+
+  console.log("\n=== TOTAL FAILURES:", failures, "===");
+  process.exit(failures === 0 ? 0 : 1);
+})().catch((e) => { console.error("QA FAIL", e); process.exit(1); });

qa_yarqa.js

@@ -0,0 +1,124 @@
+// QA — yarqa flow-compartments layer (v6) + full regression.
+// Headless Chromium, THREE r160 swiftshader. Runs desktop / 390 / 820.
+// Asserts: 0 console errors; v6 layer toggles + computes a reproducible receipt;
+// yarqa NEVER in the locked count; no regression to organ pick / camera / GPD /
+// dissection dock / mobile FAB.
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { chromium } = require('playwright');
+
+const ROOT = __dirname;
+const MIME = { '.html':'text/html', '.js':'application/javascript', '.css':'text/css' };
+
+const server = http.createServer((req,res)=>{
+  let p = req.url.split('?')[0]; if(p==='/') p='/index.html';
+  const fp = path.join(ROOT, p);
+  if(!fp.startsWith(ROOT) || !fs.existsSync(fp)){ res.writeHead(404); return res.end('nf'); }
+  res.writeHead(200,{'Content-Type':MIME[path.extname(fp)]||'application/octet-stream'});
+  fs.createReadStream(fp).pipe(res);
+});
+
+const VIEWPORTS = [
+  { name:'desktop', width:1280, height:800 },
+  { name:'phone-390', width:390, height:844 },
+  { name:'tablet-820', width:820, height:1180 },
+];
+
+async function runViewport(browser, url, vp){
+  const page = await browser.newPage({ viewport:{ width:vp.width, height:vp.height } });
+  const errors=[];
+  page.on('console', m=>{ if(m.type()==='error') errors.push(m.text()); });
+  page.on('pageerror', e=>errors.push('PAGEERROR: '+e.message));
+  await page.goto(url, { waitUntil:'networkidle' });
+  await page.waitForTimeout(2200);
+
+  const r = await page.evaluate(async ()=>{
+    const A = window.__anatomy; const out = { hasA: !!A };
+    if(!A) return out;
+    out.rev=A.rev; out.organs=A.organs; out.vessels=A.vessels; out.pulses=A.pulses;
+    out.hasV4=!!A.v4; out.hasV5=!!A.v5; out.hasV6=!!A.v6;
+
+    // ---- v6 yarqa layer ----
+    if(A.v6){
+      out.v6label = A.v6.label;
+      out.v6OffInitially = (A.v6.isOn()===false);
+      A.v6.setLayer(true,null);
+      const rec1 = await A.v6.recompute(0.2);
+      out.v6comp1 = rec1.n_compartments;
+      out.v6cells = rec1.n_cells;
+      out.v6digest1 = rec1.receipt_digest;
+      out.v6yarqaInLocked = A.v6.yarqaInLockedCount();
+      out.v6routes8 = A.v6.routesLocked8ThroughYarqa();
+      out.v6receiptTier = rec1.method_tier;
+      // reproducibility: same inputs+params => same digest
+      const rec2 = await A.v6.recompute(0.2);
+      out.v6reproduces = (rec2.receipt_digest === rec1.receipt_digest);
+      // different align => (possibly) different partition, still valid
+      const rec3 = await A.v6.recompute(0.6);
+      out.v6comp3 = rec3.n_compartments;
+      // opacity + toggle off
+      A.v6.setLayer(null,0.4);
+      A.v6.setLayer(false,null);
+      out.v6OffAfter = (A.v6.isOn()===false);
+      A.v6.setLayer(true,1);
+    }
+
+    // dock row present + honest label in DOM
+    out.dockRow = !!document.getElementById('yq-layer-row');
+    out.dockNote = (document.getElementById('yq-sec')||{}).textContent||'';
+
+    // ---- regression: v4 dock, organ pick, GPD, hud ----
+    if(A.v4){
+      out.layers = A.v4.LAYERS.map(l=>l.key);
+      out.searchYawar = A.v4.search('yawar');
+      out.jumpOpened = A.v4.jumpFirst();
+      A.v4.setLayer('circulatory', false, null);
+      out.circOff = A.v4._state.layers.circulatory.on;
+      A.v4.setLayer('circulatory', true, 1);
+      A.v4.setExplode(1); A.v4.setExplode(0);
+      A.v4.setClip(true,'y',1.2); A.v4.setClip(false,'x',0);
+      A.v4.setFocus(true); out.focus=A.v4._state.focus; A.v4.setFocus(false);
+      out.hud = A.v4.hud();
+    }
+    out.openOrgan = A.openOrgan('yawar');
+    out.panelOpen = A.panelOpen();
+    out.gpd = A.openGPD();
+    out.visHudFoot = (document.getElementById('vh-foot')||{}).textContent||'';
+    return out;
+  });
+
+  // mobile FAB presence (only visible <=680px, but element exists in DOM)
+  const fab = await page.evaluate(()=>{ const f=document.getElementById('dissect-fab'); if(!f) return null; const cs=getComputedStyle(f); return { display:cs.display }; });
+
+  // overflow check: no horizontal scroll
+  const overflow = await page.evaluate(()=>({ sw:document.documentElement.scrollWidth, iw:window.innerWidth }));
+
+  await page.close();
+  return { vp:vp.name, errors, r, fab, overflow };
+}
+
+(async()=>{
+  await new Promise(rr=>server.listen(0,rr));
+  const port = server.address().port;
+  const url = `http://localhost:${port}/index.html`;
+  const browser = await chromium.launch({
+    executablePath: process.env.PLAYWRIGHT_EXECUTABLE_PATH || undefined,
+    args:['--use-gl=angle','--use-angle=swiftshader','--ignore-gpu-blocklist','--enable-unsafe-swiftshader']
+  });
+
+  let totalErrors = 0;
+  for(const vp of VIEWPORTS){
+    const res = await runViewport(browser, url, vp);
+    console.log('\n===================== '+res.vp+' =====================');
+    console.log(JSON.stringify(res.r, null, 2));
+    console.log('FAB:', JSON.stringify(res.fab), 'overflow:', JSON.stringify(res.overflow),
+                'overflow_ok:', res.overflow.sw <= res.overflow.iw+1);
+    console.log('CONSOLE ERRORS ('+res.errors.length+'):', res.errors.length?res.errors.join('\n'):'(none)');
+    totalErrors += res.errors.length;
+  }
+  await browser.close();
+  server.close();
+  console.log('\n=== TOTAL CONSOLE ERRORS ACROSS VIEWPORTS:', totalErrors, '===');
+  process.exit(0);
+})().catch(e=>{ console.error('QA FAIL', e); process.exit(1); });

receipts.sample.json

@@ -0,0 +1,228 @@
+{
+  "schema": "szl.anatomy.covenant-cockpit/receipts/v1",
+  "note": "REAL szl-receipt in-toto sample set (DSSE ECDSA-P256-SHA256). Signatures are genuine and verify offline against cosign_pub. One receipt is UNSIGNED-honest so the cockpit shows an honest UNAVAILABLE badge \u2014 never a fabricated pass. \u039b = Conjecture 1 (advisory).",
+  "payload_type": "application/vnd.szl.receipt+json",
+  "cosign_pub": "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQW3976C9sGw2XOnLWhAaCIyLa6g9\nC/jtv7P3nQfDaQlqvtxNPx+zv+NS1JXo5zu7D62ZHFFqFNGLn8TmDKHjLQ==\n-----END PUBLIC KEY-----\n",
+  "receipts": [
+    {
+      "id": "a11oy-lead#10023-NY",
+      "envelope": {
+        "payloadType": "application/vnd.szl.receipt+json",
+        "payload": "eyJhY3Rpb24iOiJjb250YWN0X3Byb3NwZWN0IiwiYmZ0X3dpdG5lc3NlcyI6WyJhbWFydSIsInNlbnRyYSIsImtpbGxpbmNodSJdLCJlbmVyZ3kiOnsiam91bGVzIjo0MS44LCJtZWFzdXJlZCI6dHJ1ZX0sImlucHV0X2RpZ2VzdCI6InNoYTI1Njo0N2ZhNGIzNWM1YmZjNTE5NWY1OTFhZGVjZmEyMjU3YWU1YTNkYTAzZTk0NjhkODM4ZTg1M2MyZDRiYWJlMWRkIiwia2VybmVsX2NvbW1pdCI6ImM3YzBiYTE3Iiwia2luZCI6ImdvdmVybmFuY2UuZGVjaXNpb24iLCJsYW1iZGEiOnsiYXhlcyI6MTMsImZsb29yIjowLjksInBhc3MiOnRydWUsInVuaXF1ZW5lc3MiOiJDb25qZWN0dXJlIDEiLCJ2YWx1ZSI6MC45NzJ9LCJsZWFuX3RoZW9yZW0iOiJsb2NrZWRfY291bnRfZWlnaHQiLCJtb2RlbF9pZCI6InN6bC1yb3V0ZXIvbGxhbWEtMy4xLThiIiwib3V0cHV0X2RpZ2VzdCI6InNoYTI1Njo5NDIyNTM0MGFiN2E5M2M3MTQxYjM5ZGQ0ODZmNDVhMjlmZGExYWY1MDA4YTkwZGY1Nzg5NTA2M2NhMjkxMTAwIiwicG9saWN5X2lkIjoidGNwYS1jb21wbGlhbmNlLnYxMSIsInByb2R1Y2VyIjoiYTExb3kiLCJyZWFzb24iOiJPbiB0aGUgRG8tTm90LUNhbGwgcmVnaXN0cnkg4oCUIG91dHJlYWNoIGJsb2NrZWQgKFRDUEEpLiIsInNjaGVtYSI6InN6bC5wY2dpLnJlY2VpcHQvdjEiLCJzZXEiOjAsInN1YmplY3QiOiJsZWFkIzEwMDIzLU5ZIiwidmVyZGljdCI6ImJsb2NrIn0=",
+        "signature": "MEYCIQC07daoxODDMpg61Sa9FhQfBlSAjbXYTCnzpu+sIpA7igIhAP0AtdrtjkCMxh5E3XjsAhaH1/l5pr9dfgtOOG0WWyqo",
+        "signed": true,
+        "organ": "a11oy",
+        "keyid": "szl-org-key-01",
+        "digest": "0d400441089b2b09ca6291cfcb1e68662e82f51d8b43653c581ab33f572103a3",
+        "algo": "ECDSA-P256-SHA256"
+      },
+      "statement": {
+        "_type": "https://in-toto.io/Statement/v1",
+        "subject": [
+          {
+            "name": "a11oy:lead#10023-NY",
+            "digest": {
+              "sha256": "0d400441089b2b09ca6291cfcb1e68662e82f51d8b43653c581ab33f572103a3"
+            }
+          }
+        ],
+        "predicateType": "https://a-11-oy.com/attest/szl-receipt/v0.1",
+        "predicate": {
+          "buildDefinition": {
+            "buildType": "https://a-11-oy.com/pcgi/governed-decision/v1",
+            "externalParameters": {
+              "model_id": "szl-router/llama-3.1-8b",
+              "policy_id": "tcpa-compliance.v11",
+              "input_digest": "sha256:47fa4b35c5bfc5195f591adecfa2257ae5a3da03e9468d838e853c2d4babe1dd"
+            },
+            "internalParameters": {
+              "kernel_commit": "c7c0ba17"
+            }
+          },
+          "runDetails": {
+            "builder": {
+              "id": "szl://a11oy"
+            },
+            "metadata": {
+              "verdict": "block",
+              "output_digest": "sha256:94225340ab7a93c7141b39dd486f45a29fda1af5008a90df57895063ca291100",
+              "energy": {
+                "joules": 41.8,
+                "measured": true
+              },
+              "bft_witnesses": [
+                "amaru",
+                "sentra",
+                "killinchu"
+              ]
+            }
+          },
+          "doctrine": "receipt = evidence, not conformance; \u039b = Conjecture 1"
+        }
+      }
+    },
+    {
+      "id": "killinchu-track#K-7741",
+      "envelope": {
+        "payloadType": "application/vnd.szl.receipt+json",
+        "payload": "eyJhY3Rpb24iOiJ0cmFja19jbGFzc2lmeSIsImJmdF93aXRuZXNzZXMiOlsiYW1hcnUiLCJzZW50cmEiXSwiZW5lcmd5IjoiVU5BVkFJTEFCTEUiLCJpbnB1dF9kaWdlc3QiOiJzaGEyNTY6MDA5MjdmODMwMTNmNmU4OGVmOGU3ZWI2ZTMzOTYzMjI3YmVlZDIxZTU4MTRlMzRjMjYxODMxMzUyNTY0MTljZSIsImtlcm5lbF9jb21taXQiOiJjN2MwYmExNyIsImtpbmQiOiJlbmdhZ2VtZW50LmNsYXNzaWZpY2F0aW9uIiwibGFtYmRhIjp7ImF4ZXMiOjEzLCJmbG9vciI6MC45LCJwYXNzIjp0cnVlLCJ1bmlxdWVuZXNzIjoiQ29uamVjdHVyZSAxIiwidmFsdWUiOjAuOTU4fSwibGVhbl90aGVvcmVtIjoia2hpcHVfcXVvcnVtX3NhZmV0eV9jb25kaXRpb25hbCIsIm1vZGVsX2lkIjoia2lsbGluY2h1L2VkZ2UtZm9ybXVsYXMucm91bmQ5Iiwib3V0cHV0X2RpZ2VzdCI6InNoYTI1NjphNTQ3ZWI3NDg4YzE5NWIzNWE1ZTY2MThlNTJjZDA4ZjQ4MzBhODMyMjBkYjRmODlhZmZjOWJkYjhkNDQ0NTliIiwicG9saWN5X2lkIjoicm9lLWh1bWFuLWF1dGhvcml0eS52MyIsInByb2R1Y2VyIjoia2lsbGluY2h1IiwicmVhc29uIjoiQ2xhc3NpZmllZCBOT04tSE9TVElMRSB1bmRlciBST0UgZ2F0ZTsgaHVtYW4gYXV0aG9yaXR5IHJldGFpbmVkLiIsInNjaGVtYSI6InN6bC5wY2dpLnJlY2VpcHQvdjEiLCJzZXEiOjEsInN1YmplY3QiOiJ0cmFjayNLLTc3NDEiLCJ2ZXJkaWN0IjoiYWxsb3ctb2JzZXJ2ZSJ9",
+        "signature": "MEQCIB/Bn4eRv/QRVhmQQQwYLyJh1InUwKPrgvvKrxg+DtsWAiAwuAzxKvESYM/0SORx+CE0yFzpa+Os7SJ6SWfmDb7xpQ==",
+        "signed": true,
+        "organ": "killinchu",
+        "keyid": "szl-org-key-01",
+        "digest": "291e7ecece7d88445ce4b5abf3c9fea0596567a8f2f6c05e3b4a0a8ee4e705db",
+        "algo": "ECDSA-P256-SHA256"
+      },
+      "statement": {
+        "_type": "https://in-toto.io/Statement/v1",
+        "subject": [
+          {
+            "name": "killinchu:track#K-7741",
+            "digest": {
+              "sha256": "291e7ecece7d88445ce4b5abf3c9fea0596567a8f2f6c05e3b4a0a8ee4e705db"
+            }
+          }
+        ],
+        "predicateType": "https://a-11-oy.com/attest/szl-receipt/v0.1",
+        "predicate": {
+          "buildDefinition": {
+            "buildType": "https://a-11-oy.com/pcgi/governed-decision/v1",
+            "externalParameters": {
+              "model_id": "killinchu/edge-formulas.round9",
+              "policy_id": "roe-human-authority.v3",
+              "input_digest": "sha256:00927f83013f6e88ef8e7eb6e33963227beed21e5814e34c26183135256419ce"
+            },
+            "internalParameters": {
+              "kernel_commit": "c7c0ba17"
+            }
+          },
+          "runDetails": {
+            "builder": {
+              "id": "szl://killinchu"
+            },
+            "metadata": {
+              "verdict": "allow-observe",
+              "output_digest": "sha256:a547eb7488c195b35a5e6618e52cd08f4830a83220db4f89affc9bdb8d44459b",
+              "energy": "UNAVAILABLE",
+              "bft_witnesses": [
+                "amaru",
+                "sentra"
+              ]
+            }
+          },
+          "doctrine": "receipt = evidence, not conformance; \u039b = Conjecture 1"
+        }
+      }
+    },
+    {
+      "id": "a11oy-req#88f120",
+      "envelope": {
+        "payloadType": "application/vnd.szl.receipt+json",
+        "payload": "eyJhY3Rpb24iOiJhbnN3ZXJfcXVlcnkiLCJiZnRfd2l0bmVzc2VzIjpbImFtYXJ1Iiwic2VudHJhIiwia2lsbGluY2h1Il0sImVuZXJneSI6eyJqb3VsZXMiOjExOC4zLCJtZWFzdXJlZCI6dHJ1ZX0sImlucHV0X2RpZ2VzdCI6InNoYTI1NjowNWMxOTE2MmQ2YzU0YmQyYjk3NjVkN2JiNDIzMGRhMDgyNmE2MDk2NWZhZjg1MWE3MzgxNzA3NzQ5NzM5ZWVkIiwia2VybmVsX2NvbW1pdCI6ImM3YzBiYTE3Iiwia2luZCI6ImluZmVyZW5jZS5kZWNpc2lvbiIsImxhbWJkYSI6eyJheGVzIjoxMywiZmxvb3IiOjAuOSwicGFzcyI6dHJ1ZSwidW5pcXVlbmVzcyI6IkNvbmplY3R1cmUgMSIsInZhbHVlIjowLjk5MX0sImxlYW5fdGhlb3JlbSI6ImxvY2tlZF9jb3VudF9laWdodCIsIm1vZGVsX2lkIjoic3psLXJvdXRlci9sbGFtYS0zLjEtOGIiLCJvdXRwdXRfZGlnZXN0Ijoic2hhMjU2OjQyNmQ5YWY2MjVhNDAxMzQ0YjFlNjQ5MjFhMWUxMWQ0YWVjNjM0MDRjMmIxMzc4NWVkZTdhM2Q3ZTY3MDI5ZDkiLCJwb2xpY3lfaWQiOiJkZW55LWJ5LWRlZmF1bHQuRjEyLnYxMSIsInByb2R1Y2VyIjoiYTExb3kiLCJyZWFzb24iOiJEZW55LWJ5LWRlZmF1bHQgZ2F0ZSBwYXNzZWQgMTMvMTMgY29uanVuY3RpdmUgYXhlcy4iLCJzY2hlbWEiOiJzemwucGNnaS5yZWNlaXB0L3YxIiwic2VxIjoyLCJzdWJqZWN0IjoicmVxIzg4ZjEyMCIsInZlcmRpY3QiOiJhbGxvdyJ9",
+        "signature": "MEYCIQCYhSRuaVXES0Gri9RM+6kL0sx6NKca2TTEMYy48ewehQIhAKwz3FqRrkmQ52DknWtyaM4MT4XtF+hsp1M4ZdMb7BMq",
+        "signed": true,
+        "organ": "a11oy",
+        "keyid": "szl-org-key-01",
+        "digest": "19c7e9e5632e925e8f1241da6933fe8d6cc657d284f1afe5f34f9c592be69d9a",
+        "algo": "ECDSA-P256-SHA256"
+      },
+      "statement": {
+        "_type": "https://in-toto.io/Statement/v1",
+        "subject": [
+          {
+            "name": "a11oy:req#88f120",
+            "digest": {
+              "sha256": "19c7e9e5632e925e8f1241da6933fe8d6cc657d284f1afe5f34f9c592be69d9a"
+            }
+          }
+        ],
+        "predicateType": "https://a-11-oy.com/attest/szl-receipt/v0.1",
+        "predicate": {
+          "buildDefinition": {
+            "buildType": "https://a-11-oy.com/pcgi/governed-decision/v1",
+            "externalParameters": {
+              "model_id": "szl-router/llama-3.1-8b",
+              "policy_id": "deny-by-default.F12.v11",
+              "input_digest": "sha256:05c19162d6c54bd2b9765d7bb4230da0826a60965faf851a7381707749739eed"
+            },
+            "internalParameters": {
+              "kernel_commit": "c7c0ba17"
+            }
+          },
+          "runDetails": {
+            "builder": {
+              "id": "szl://a11oy"
+            },
+            "metadata": {
+              "verdict": "allow",
+              "output_digest": "sha256:426d9af625a401344b1e64921a1e11d4aec63404c2b13785ede7a3d7e67029d9",
+              "energy": {
+                "joules": 118.3,
+                "measured": true
+              },
+              "bft_witnesses": [
+                "amaru",
+                "sentra",
+                "killinchu"
+              ]
+            }
+          },
+          "doctrine": "receipt = evidence, not conformance; \u039b = Conjecture 1"
+        }
+      }
+    },
+    {
+      "id": "a11oy-req#88f201",
+      "envelope": {
+        "payloadType": "application/vnd.szl.receipt+json",
+        "payload": "eyJhY3Rpb24iOiJoaWRkZW5fcmVhc29uaW5nX2V4dHJhY3Rpb24iLCJiZnRfd2l0bmVzc2VzIjpbImFtYXJ1Il0sImVuZXJneSI6IlVOQVZBSUxBQkxFIiwiaW5wdXRfZGlnZXN0Ijoic2hhMjU2OmM3ZDBlZWJkMzUwNWJmZjBjNTYwNjU3ZWFiMWZlNTRmNWQ5NjRmMTNkYTI4OWM1ZjYzY2FiNmMxZTE2ZGVmMzgiLCJrZXJuZWxfY29tbWl0IjoiYzdjMGJhMTciLCJraW5kIjoiZ292ZXJuYW5jZS5kZWNpc2lvbiIsImxhbWJkYSI6eyJheGVzIjoxMywiZmxvb3IiOjAuOSwicGFzcyI6dHJ1ZSwidW5pcXVlbmVzcyI6IkNvbmplY3R1cmUgMSIsInZhbHVlIjowLjk2NX0sImxlYW5fdGhlb3JlbSI6ImxvY2tlZF9jb3VudF9laWdodCIsIm1vZGVsX2lkIjoic3psLXJvdXRlci9sbGFtYS0zLjEtOGIiLCJvdXRwdXRfZGlnZXN0Ijoic2hhMjU2OmY4MzU4YzExNjM2YzllMGZhNWQ1MzIxN2VmZjE0ZDAwMGEyZjNiNzQyMjE1YjVhZDI1OGZjMjhhZGE5YjA1M2QiLCJwb2xpY3lfaWQiOiJ3aWxsYXktY29uc2NpZW5jZS52NSIsInByb2R1Y2VyIjoiYTExb3kiLCJyZWFzb24iOiJXSUxMQVkgY29uc2NpZW5jZSBnYXRlOiBoaWRkZW4tcmVhc29uaW5nIGV4dHJhY3Rpb24gYXR0ZW1wdCByZWZ1c2VkLiIsInNjaGVtYSI6InN6bC5wY2dpLnJlY2VpcHQvdjEiLCJzZXEiOjMsInN1YmplY3QiOiJyZXEjODhmMjAxIiwidmVyZGljdCI6ImJsb2NrIn0=",
+        "signature": "",
+        "signed": false,
+        "organ": "a11oy",
+        "keyid": "",
+        "digest": "aa048ce1d842952dd77b5e599658d1d2d670eaa7412d6a9de89e5895a6fb1992",
+        "algo": "UNSIGNED",
+        "note": "UNSIGNED-honest: no cosign key present"
+      },
+      "statement": {
+        "_type": "https://in-toto.io/Statement/v1",
+        "subject": [
+          {
+            "name": "a11oy:req#88f201",
+            "digest": {
+              "sha256": "aa048ce1d842952dd77b5e599658d1d2d670eaa7412d6a9de89e5895a6fb1992"
+            }
+          }
+        ],
+        "predicateType": "https://a-11-oy.com/attest/szl-receipt/v0.1",
+        "predicate": {
+          "buildDefinition": {
+            "buildType": "https://a-11-oy.com/pcgi/governed-decision/v1",
+            "externalParameters": {
+              "model_id": "szl-router/llama-3.1-8b",
+              "policy_id": "willay-conscience.v5",
+              "input_digest": "sha256:c7d0eebd3505bff0c560657eab1fe54f5d964f13da289c5f63cab6c1e16def38"
+            },
+            "internalParameters": {
+              "kernel_commit": "c7c0ba17"
+            }
+          },
+          "runDetails": {
+            "builder": {
+              "id": "szl://a11oy"
+            },
+            "metadata": {
+              "verdict": "block",
+              "output_digest": "sha256:f8358c11636c9e0fa5d53217eff14d000a2f3b742215b5ad258fc28ada9b053d",
+              "energy": "UNAVAILABLE",
+              "bft_witnesses": [
+                "amaru"
+              ]
+            }
+          },
+          "doctrine": "receipt = evidence, not conformance; \u039b = Conjecture 1"
+        }
+      }
+    }
+  ]
+}

scripts/materialize_second_brain.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Materialize the public Second Brain projection for Living Anatomy.
+
+The source repository remains authoritative. This operator resolves an exact
+Git commit, downloads the public manifest and JSONL corpus from that immutable
+revision, validates every row digest and the declared chunk count, then writes a
+source receipt beside the snapshot. It never reads or exports the private
+Second Brain graph.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import tempfile
+import urllib.error
+import urllib.parse
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+DEFAULT_REPOSITORY = "szl-holdings/szl-second-brain"
+DEFAULT_REF = "main"
+EXPECTED_PUBLIC_CHUNKS = 575
+MAX_MANIFEST_BYTES = 256 * 1024
+MAX_CORPUS_BYTES = 4 * 1024 * 1024
+USER_AGENT = "szl-living-anatomy-second-brain-materializer/1.0"
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def sha256_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def request_bytes(url: str, *, token: str | None = None, limit: int) -> bytes:
+    headers = {
+        "Accept": "application/vnd.github+json, application/json, text/plain;q=0.9, */*;q=0.8",
+        "User-Agent": USER_AGENT,
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    request = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(request, timeout=45) as response:
+            body = response.read(limit + 1)
+    except (urllib.error.URLError, TimeoutError, ConnectionError) as exc:
+        raise RuntimeError(f"fetch failed for {url}: {type(exc).__name__}: {exc}") from exc
+    if len(body) > limit:
+        raise RuntimeError(f"response exceeded {limit} bytes: {url}")
+    return body
+
+
+def resolve_revision(
+    repository: str,
+    ref: str,
+    *,
+    token: str | None = None,
+    api_url: str = "https://api.github.com",
+) -> str:
+    if not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", repository):
+        raise ValueError(f"invalid GitHub repository: {repository!r}")
+    encoded_ref = urllib.parse.quote(ref, safe="")
+    url = f"{api_url.rstrip('/')}/repos/{repository}/commits/{encoded_ref}"
+    try:
+        raw = request_bytes(url, token=token, limit=MAX_MANIFEST_BYTES)
+    except RuntimeError:
+        # A repository-scoped Actions token can lack cross-repo read permission
+        # even when the source repository is public. Retry the immutable public
+        # read without credentials; never broaden token scope.
+        if not token:
+            raise
+        raw = request_bytes(url, token=None, limit=MAX_MANIFEST_BYTES)
+    payload = json.loads(raw)
+    revision = str(payload.get("sha") or "").lower() if isinstance(payload, dict) else ""
+    if not re.fullmatch(r"[0-9a-f]{40}", revision):
+        raise RuntimeError("GitHub did not return an exact source revision")
+    return revision
+
+
+def validate_snapshot(
+    manifest_raw: bytes,
+    corpus_raw: bytes,
+    *,
+    expected_chunks: int = EXPECTED_PUBLIC_CHUNKS,
+) -> dict[str, Any]:
+    manifest = json.loads(manifest_raw.decode("utf-8"))
+    if not isinstance(manifest, dict):
+        raise ValueError("manifest must be a JSON object")
+    if str(manifest.get("secretScan") or "").upper() != "PASS":
+        raise ValueError("public projection secretScan must be PASS")
+
+    rows = 0
+    by_source: dict[str, int] = {}
+    ids: set[str] = set()
+    for line_number, line in enumerate(corpus_raw.decode("utf-8").splitlines(), start=1):
+        if not line.strip():
+            continue
+        row = json.loads(line)
+        if not isinstance(row, dict) or not row.get("id"):
+            raise ValueError(f"invalid corpus row at line {line_number}")
+        node_id = str(row["id"])
+        if node_id in ids:
+            raise ValueError(f"duplicate corpus id at line {line_number}: {node_id}")
+        ids.add(node_id)
+        text = str(row.get("text") or "")
+        declared = str(row.get("sha256") or "")
+        measured = sha256_bytes(text.encode("utf-8"))
+        if declared and declared != measured:
+            raise ValueError(f"row digest mismatch at line {line_number}: {node_id}")
+        source = str(row.get("source") or "unknown")
+        by_source[source] = by_source.get(source, 0) + 1
+        rows += 1
+
+    declared_count = int(manifest.get("publicChunkCount") or 0)
+    if rows != declared_count or rows != expected_chunks:
+        raise ValueError(
+            f"public chunk count mismatch: loaded={rows}, manifest={declared_count}, expected={expected_chunks}"
+        )
+    declared_by_source = manifest.get("bySource")
+    if isinstance(declared_by_source, dict):
+        normalized = {str(key): int(value) for key, value in declared_by_source.items()}
+        if normalized != by_source:
+            raise ValueError(
+                f"source histogram mismatch: loaded={by_source}, manifest={normalized}"
+            )
+    return {
+        "public_chunk_count": rows,
+        "by_source": by_source,
+        "manifest_sha256": sha256_bytes(manifest_raw),
+        "corpus_sha256": sha256_bytes(corpus_raw),
+        "manifest_projection_sha256": manifest.get("projectionSha256"),
+        "secret_scan": "PASS",
+    }
+
+
+def atomic_write(path: Path, payload: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        dir=path.parent,
+        prefix=f".{path.name}.",
+        delete=False,
+    ) as handle:
+        handle.write(payload)
+        handle.flush()
+        os.fsync(handle.fileno())
+        temporary = Path(handle.name)
+    os.replace(temporary, path)
+
+
+def materialize(
+    output: Path,
+    *,
+    repository: str = DEFAULT_REPOSITORY,
+    ref: str = DEFAULT_REF,
+    token: str | None = None,
+    api_url: str = "https://api.github.com",
+    raw_url: str = "https://raw.githubusercontent.com",
+) -> dict[str, Any]:
+    revision = resolve_revision(repository, ref, token=token, api_url=api_url)
+    immutable_base = f"{raw_url.rstrip('/')}/{repository}/{revision}/data"
+    manifest_raw = request_bytes(
+        f"{immutable_base}/manifest.json",
+        limit=MAX_MANIFEST_BYTES,
+    )
+    corpus_raw = request_bytes(
+        f"{immutable_base}/brain-corpus.public.jsonl",
+        limit=MAX_CORPUS_BYTES,
+    )
+    validation = validate_snapshot(manifest_raw, corpus_raw)
+    receipt = {
+        "schema": "szl.second-brain.snapshot/v1",
+        "source_repository": repository,
+        "source_ref": ref,
+        "source_revision": revision,
+        "source_relation": "github-exact-revision-public-projection",
+        "canonical_dataset": "SZLHOLDINGS/szl-second-brain-inrepo",
+        "manifest_path": "data/manifest.json",
+        "corpus_path": "data/brain-corpus.public.jsonl",
+        "manifest_sha256": validation["manifest_sha256"],
+        "corpus_sha256": validation["corpus_sha256"],
+        "manifest_projection_sha256": validation["manifest_projection_sha256"],
+        "public_chunk_count": validation["public_chunk_count"],
+        "by_source": validation["by_source"],
+        "secret_scan": validation["secret_scan"],
+        "materialized_at": utc_now(),
+        "authority_state": "READ_ONLY",
+        "content_access": "HANDLES_ONLY",
+        "private_graph_nodes_materialized": 0,
+        "raw_graph_nodes_admitted_to_gradients": 0,
+        "lambda_state": "CONJECTURE_1",
+    }
+    atomic_write(output / "manifest.json", manifest_raw)
+    atomic_write(output / "brain-corpus.public.jsonl", corpus_raw)
+    atomic_write(
+        output / "source.json",
+        (json.dumps(receipt, sort_keys=True, indent=2) + "\n").encode("utf-8"),
+    )
+    return receipt
+
+
+def token_from_environment() -> str | None:
+    for key in ("GH_READ_TOKEN", "GH_ADMIN_TOKEN", "GITHUB_TOKEN"):
+        value = os.environ.get(key)
+        if value and value.strip():
+            return value.strip()
+    return None
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, default=Path(".runtime/second-brain"))
+    parser.add_argument("--repository", default=DEFAULT_REPOSITORY)
+    parser.add_argument("--ref", default=DEFAULT_REF)
+    parser.add_argument("--api-url", default=os.environ.get("GITHUB_API_URL", "https://api.github.com"))
+    parser.add_argument("--raw-url", default="https://raw.githubusercontent.com")
+    args = parser.parse_args()
+    receipt = materialize(
+        args.output,
+        repository=args.repository,
+        ref=args.ref,
+        token=token_from_environment(),
+        api_url=args.api_url,
+        raw_url=args.raw_url,
+    )
+    print(
+        json.dumps(
+            {
+                "source_repository": receipt["source_repository"],
+                "source_revision": receipt["source_revision"],
+                "public_chunk_count": receipt["public_chunk_count"],
+                "corpus_sha256": receipt["corpus_sha256"],
+                "output": str(args.output),
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

second_brain_runtime.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Source-bound public Second Brain runtime for SZL Living Anatomy.
+
+This module is deliberately read-only. It loads the public, source-bound
+Second Brain projection bundled by the deployment workflow, validates the
+snapshot receipt, and exposes lexical retrieval as handles only. It never
+loads the owner's private graph, never returns corpus text, never trains model
+weights, and never grants write authority.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import re
+import threading
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+SCHEMA_HEALTH = "szl.living-anatomy.second-brain.health/v1"
+SCHEMA_SEARCH = "szl.living-anatomy.second-brain.search/v1"
+SCHEMA_CONTEXT = "szl.living-anatomy.second-brain.context/v1"
+SCHEMA_MANIFEST = "szl.living-anatomy.second-brain.manifest/v1"
+SOURCE_REPOSITORY = "szl-holdings/szl-second-brain"
+CANONICAL_DATASET = "SZLHOLDINGS/szl-second-brain-inrepo"
+PUBLIC_CHUNK_COUNT = 575
+PRIVATE_GRAPH_NODES_DISCLOSED = 9464
+MAX_QUERY_CHARS = 500
+MAX_K = 12
+
+TOKEN = re.compile(r"[a-z0-9λ]+", re.I)
+STOP = {
+    "the", "is", "a", "an", "of", "and", "or", "to", "in", "for", "on", "at",
+    "by", "as", "what", "which", "who", "how", "why", "does", "did", "are",
+    "was", "be", "it", "this", "that", "with", "from", "into", "over", "not",
+}
+
+ROOT = Path(__file__).resolve().parent
+SNAPSHOT_ROOT = Path(
+    os.environ.get(
+        "SECOND_BRAIN_SNAPSHOT_ROOT",
+        str(ROOT / ".runtime" / "second-brain"),
+    )
+).resolve()
+MANIFEST_PATH = SNAPSHOT_ROOT / "manifest.json"
+CORPUS_PATH = SNAPSHOT_ROOT / "brain-corpus.public.jsonl"
+SOURCE_PATH = SNAPSHOT_ROOT / "source.json"
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def _sha256_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def _canonical_sha256(value: Any) -> str:
+    return _sha256_bytes(
+        json.dumps(
+            value,
+            sort_keys=True,
+            separators=(",", ":"),
+            ensure_ascii=False,
+        ).encode("utf-8")
+    )
+
+
+def _tokenize(value: str) -> list[str]:
+    return [
+        token.lower()
+        for token in TOKEN.findall(value or "")
+        if len(token) > 1 and token.lower() not in STOP
+    ]
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"{path.name} must contain a JSON object")
+    return payload
+
+
+def _valid_revision(value: Any) -> bool:
+    return isinstance(value, str) and bool(re.fullmatch(r"[0-9a-f]{40}", value.lower()))
+
+
+class PublicSecondBrain:
+    """Validated lexical index over the public handles-only projection."""
+
+    def __init__(self, snapshot_root: Path | None = None) -> None:
+        self.snapshot_root = Path(snapshot_root or SNAPSHOT_ROOT).resolve()
+        self.manifest_path = self.snapshot_root / "manifest.json"
+        self.corpus_path = self.snapshot_root / "brain-corpus.public.jsonl"
+        self.source_path = self.snapshot_root / "source.json"
+        self._lock = threading.RLock()
+        self._rows: list[dict[str, Any]] = []
+        self._df: Counter[str] = Counter()
+        self._manifest: dict[str, Any] = {}
+        self._source: dict[str, Any] = {}
+        self._load_error: str | None = None
+        self._loaded_at: str | None = None
+        self.reload()
+
+    def reload(self) -> dict[str, Any]:
+        with self._lock:
+            self._rows = []
+            self._df = Counter()
+            self._manifest = {}
+            self._source = {}
+            self._load_error = None
+            self._loaded_at = None
+            try:
+                manifest_raw = self.manifest_path.read_bytes()
+                corpus_raw = self.corpus_path.read_bytes()
+                source = _read_json(self.source_path)
+                manifest = json.loads(manifest_raw.decode("utf-8"))
+                if not isinstance(manifest, dict):
+                    raise ValueError("manifest.json must contain a JSON object")
+                if source.get("schema") != "szl.second-brain.snapshot/v1":
+                    raise ValueError("unsupported source receipt schema")
+                if source.get("source_repository") != SOURCE_REPOSITORY:
+                    raise ValueError("unexpected Second Brain source repository")
+                if not _valid_revision(source.get("source_revision")):
+                    raise ValueError("Second Brain source revision is not an exact Git SHA")
+                if source.get("manifest_sha256") != _sha256_bytes(manifest_raw):
+                    raise ValueError("Second Brain manifest digest mismatch")
+                if source.get("corpus_sha256") != _sha256_bytes(corpus_raw):
+                    raise ValueError("Second Brain corpus digest mismatch")
+
+                rows: list[dict[str, Any]] = []
+                document_frequency: Counter[str] = Counter()
+                for line_number, line in enumerate(corpus_raw.decode("utf-8").splitlines(), start=1):
+                    if not line.strip():
+                        continue
+                    row = json.loads(line)
+                    if not isinstance(row, dict) or not row.get("id"):
+                        raise ValueError(f"invalid corpus row at line {line_number}")
+                    text = str(row.get("text") or "")
+                    declared_digest = str(row.get("sha256") or "")
+                    measured_digest = _sha256_bytes(text.encode("utf-8"))
+                    if declared_digest and declared_digest != measured_digest:
+                        raise ValueError(f"row digest mismatch at line {line_number}")
+                    tokens = _tokenize(f"{row.get('title', '')} {text}")
+                    stored = {
+                        "id": str(row["id"]),
+                        "title": str(row.get("title") or ""),
+                        "source": str(row.get("source") or "unknown"),
+                        "sourceId": row.get("sourceId"),
+                        "sha256": measured_digest,
+                        "_tf": Counter(tokens),
+                    }
+                    rows.append(stored)
+                    document_frequency.update(set(tokens))
+
+                declared_count = int(manifest.get("publicChunkCount") or 0)
+                receipt_count = int(source.get("public_chunk_count") or 0)
+                if declared_count != len(rows) or receipt_count != len(rows):
+                    raise ValueError(
+                        "public chunk count mismatch "
+                        f"(manifest={declared_count}, receipt={receipt_count}, loaded={len(rows)})"
+                    )
+                if len(rows) != PUBLIC_CHUNK_COUNT:
+                    raise ValueError(
+                        f"expected {PUBLIC_CHUNK_COUNT} public chunks, loaded {len(rows)}"
+                    )
+                if str(manifest.get("secretScan") or "").upper() != "PASS":
+                    raise ValueError("public projection secret scan is not PASS")
+
+                self._rows = rows
+                self._df = document_frequency
+                self._manifest = manifest
+                self._source = source
+                self._loaded_at = _utc_now()
+            except Exception as exc:
+                self._load_error = f"{type(exc).__name__}: {exc}"
+            return self.health()
+
+    @property
+    def ready(self) -> bool:
+        return self._load_error is None and len(self._rows) == PUBLIC_CHUNK_COUNT
+
+    @property
+    def source_revision(self) -> str | None:
+        value = self._source.get("source_revision")
+        return str(value) if _valid_revision(value) else None
+
+    def health(self) -> dict[str, Any]:
+        with self._lock:
+            by_source: dict[str, int] = {}
+            for row in self._rows:
+                source = str(row.get("source") or "unknown")
+                by_source[source] = by_source.get(source, 0) + 1
+            return {
+                "schema": SCHEMA_HEALTH,
+                "service": "living-anatomy-yachay-second-brain",
+                "ready": self.ready,
+                "state": "SOURCE_BOUND_PUBLIC_PROJECTION" if self.ready else "UNAVAILABLE",
+                "transport_state": "REACHABLE",
+                "evidence_state": "MEASURED" if self.ready else "UNAVAILABLE",
+                "verification_state": "STRUCTURAL_ONLY" if self.ready else "FAILED",
+                "authority_state": "READ_ONLY",
+                "kind": "SOFTWARE",
+                "content_access": "HANDLES_ONLY",
+                "source_repository": SOURCE_REPOSITORY,
+                "source_revision": self.source_revision,
+                "canonical_dataset": CANONICAL_DATASET,
+                "chunk_count": len(self._rows),
+                "declared_public_chunk_count": PUBLIC_CHUNK_COUNT,
+                "by_source": by_source,
+                "snapshot_root": str(self.snapshot_root),
+                "loaded_at": self._loaded_at,
+                "load_error": self._load_error,
+                "index_is_model_weights": False,
+                "private_graph_nodes_loaded": 0,
+                "private_graph_nodes_disclosed_elsewhere": PRIVATE_GRAPH_NODES_DISCLOSED,
+                "raw_graph_nodes_admitted_to_gradients": 0,
+                "lambda_state": "CONJECTURE_1",
+                "limits": [
+                    "Lexical overlap is not correctness.",
+                    "Only public handles are returned; corpus text remains inside the controller.",
+                    "The owner's private graph is not bundled, queried, or exposed.",
+                    "This read-only organ cannot authorize or execute an action.",
+                ],
+            }
+
+    def manifest(self) -> dict[str, Any]:
+        health = self.health()
+        return {
+            "schema": SCHEMA_MANIFEST,
+            "service": health["service"],
+            "ready": health["ready"],
+            "source": {
+                "repository": SOURCE_REPOSITORY,
+                "revision": self.source_revision,
+                "dataset": CANONICAL_DATASET,
+                "snapshot_receipt": self._source,
+            },
+            "corpus": {
+                "chunk_count": len(self._rows),
+                "by_source": health["by_source"],
+                "manifest": self._manifest,
+            },
+            "interfaces": {
+                "health": "/api/anatomy/v1/brain/health",
+                "manifest": "/api/anatomy/v1/brain/manifest",
+                "search": "/api/anatomy/v1/brain/search",
+                "context": "/api/anatomy/v1/brain/context",
+            },
+            "authority_state": "READ_ONLY",
+            "content_access": "HANDLES_ONLY",
+            "limits": health["limits"],
+        }
+
+    @staticmethod
+    def _handle(row: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "nodeId": row["id"],
+            "nodeKind": "INDEX",
+            "label": "DECLARED",
+            "note": str(row.get("title") or "")[:160],
+            "source": row.get("source"),
+            "sourceId": row.get("sourceId"),
+            "sha256": row.get("sha256"),
+        }
+
+    def search(self, query: str, k: int = 6) -> dict[str, Any]:
+        query = str(query or "").strip()
+        if len(query) > MAX_QUERY_CHARS:
+            query = query[:MAX_QUERY_CHARS]
+        try:
+            requested_k = int(k)
+        except (TypeError, ValueError):
+            requested_k = 6
+        requested_k = max(1, min(requested_k, MAX_K))
+
+        with self._lock:
+            if not self.ready:
+                return {
+                    "schema": SCHEMA_SEARCH,
+                    "ready": False,
+                    "query": query,
+                    "handles": [],
+                    "scores": [],
+                    "source_revision": self.source_revision,
+                    "error": self._load_error or "Second Brain snapshot unavailable",
+                    "authority_state": "READ_ONLY",
+                    "content_access": "HANDLES_ONLY",
+                }
+            query_tokens = _tokenize(query)
+            if not query_tokens:
+                return {
+                    "schema": SCHEMA_SEARCH,
+                    "ready": True,
+                    "query": query,
+                    "handles": [],
+                    "scores": [],
+                    "source_revision": self.source_revision,
+                    "honesty": "Empty or stop-word-only query; no ranking fabricated.",
+                    "authority_state": "READ_ONLY",
+                    "content_access": "HANDLES_ONLY",
+                }
+
+            query_frequency = Counter(query_tokens)
+            scored: list[tuple[float, dict[str, Any]]] = []
+            total = max(1, len(self._rows))
+            for row in self._rows:
+                score = 0.0
+                row_frequency: Counter[str] = row["_tf"]
+                for term, query_count in query_frequency.items():
+                    term_frequency = row_frequency.get(term, 0)
+                    if not term_frequency:
+                        continue
+                    inverse_document_frequency = (
+                        math.log((total + 1) / (1 + self._df.get(term, 0))) + 1.0
+                    )
+                    score += (
+                        term_frequency / (term_frequency + 1.2)
+                    ) * inverse_document_frequency * query_count
+                if score > 0:
+                    scored.append((score, row))
+            scored.sort(key=lambda item: (-item[0], str(item[1]["id"])))
+            top = scored[:requested_k]
+            handles = [self._handle(row) for _, row in top]
+            scores = [round(score, 6) for score, _ in top]
+            result_body = {
+                "query": query,
+                "handles": handles,
+                "scores": scores,
+                "source_revision": self.source_revision,
+                "corpus_chunk_count": len(self._rows),
+                "ranking": "BM25_LIKE_LEXICAL",
+                "content_access": "HANDLES_ONLY",
+            }
+            return {
+                "schema": SCHEMA_SEARCH,
+                "ready": True,
+                **result_body,
+                "result_sha256": _canonical_sha256(result_body),
+                "authority_state": "READ_ONLY",
+                "index_is_model_weights": False,
+                "honesty": (
+                    "Ranked lexical overlap over the public source-bound projection; "
+                    "scores are relevance signals, never correctness or proof."
+                ),
+            }
+
+    def context(self, query: str, k: int = 6) -> dict[str, Any]:
+        search = self.search(query, k=k)
+        handles = search.get("handles") if isinstance(search, dict) else []
+        handles = handles if isinstance(handles, list) else []
+        model_handles = [
+            {
+                key: handle[key]
+                for key in ("nodeId", "nodeKind", "label", "note")
+                if key in handle
+            }
+            for handle in handles
+            if isinstance(handle, dict)
+        ]
+        evidence = [
+            {
+                "node_id": handle.get("nodeId"),
+                "source": handle.get("source"),
+                "source_id": handle.get("sourceId"),
+                "sha256": handle.get("sha256"),
+            }
+            for handle in handles
+            if isinstance(handle, dict)
+        ]
+        body = {
+            "query": search.get("query"),
+            "model_handles": model_handles,
+            "evidence": evidence,
+            "source_revision": search.get("source_revision"),
+            "ready": bool(search.get("ready")),
+        }
+        return {
+            "schema": SCHEMA_CONTEXT,
+            **body,
+            "context_sha256": _canonical_sha256(body),
+            "training_authority": "NONE",
+            "write_authority": "NONE",
+            "private_graph_nodes_loaded": 0,
+            "honesty": search.get("honesty"),
+            "error": search.get("error"),
+        }

server.py

@@ -0,0 +1,1088 @@
+#!/usr/bin/env python3
+"""SZL Living Anatomy server and evidence contract.
+
+The visual bundle remains static and read-only.  This thin server adds an honest
+machine-readable boundary around it:
+
+* ``/healthz`` reports transport health only.
+* ``/version`` exposes the exact source and deployed Space revisions using the
+  shared vertical-conformance identity contract.
+* ``/evidence`` indexes the source binding, local bundle receipt, and measured
+  dependency posture without upgrading structural checks to signed proof.
+* ``/.well-known/szl-source.json`` identifies the GitHub source and live HF
+  revision without pretending that the two revisions are identical.
+* ``/api/anatomy/v1/manifest`` describes the contract and status vocabulary.
+* ``/api/anatomy/v1/capabilities`` exposes Purpose / Try / Evidence / Limits /
+  Reproduce for each major surface.
+* ``/api/anatomy/v1/evidence`` separately probes the live dependencies.
+* ``/api/anatomy/v1/receipt`` hashes the files that make up the bundle.
+* ``POST /api/anatomy/v1/verify/receipt`` recomputes that local integrity
+  receipt.  The result is deliberately ``STRUCTURAL-ONLY`` because this Space
+  has no signing key; it never upgrades an unsigned receipt to cryptographically
+  VERIFIED.
+* ``GET/POST /api/anatomy/v1/organs/integrity`` runs the five-organ fail-closed
+  kernel (HEART/YUYAY, BRAIN/YACHAY, CIRCULATORY/YAWAR, NERVOUS/OTel,
+  SKELETON/Khipu). Energy stays UNAVAILABLE. Λ is Conjecture 1 OPEN.
+
+No endpoint mutates state, signs data, runs a model, or claims that reachability
+proves model quality.  Lambda remains Conjecture 1 and the Space does not execute
+Lean; formal claims are presented as a declared, linked snapshot.
+"""
+
+from __future__ import annotations
+
+import functools
+import hashlib
+import json
+import os
+import threading
+import time
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlsplit
+
+try:
+    from organ_integrity import envelope as _org_envelope
+    from organ_integrity import evaluate_anatomy as _evaluate_anatomy
+    from organ_integrity import parse_flags as _org_parse_flags
+    _ORGAN_INTEGRITY = True
+except Exception:
+    _ORGAN_INTEGRITY = False
+    _org_envelope = None
+    _evaluate_anatomy = None
+    _org_parse_flags = None
+
+
+PORT = int(os.environ.get("PORT", "7860"))
+# Resolve from this file, not from a generic /app existence check.  The Docker
+# image places server.py in /app already; local verification must never
+# accidentally serve an unrelated host-level /app directory.
+DIRECTORY = Path(os.environ.get("ANATOMY_ROOT", str(Path(__file__).resolve().parent))).resolve()
+SPACE_ID = "betterwithage/anatomy"
+SOURCE_REPOSITORY = "szl-holdings/anatomy"
+SOURCE_BASE_COMMIT = "9847b3031c1aacdcee9aa8e37ae33d573737a5c4"
+DEPLOY_MANIFEST_PATH = DIRECTORY / "hf-deploy-manifest.json"
+DOCTRINE = "v11"
+LOCK = "749/14/163"
+KERNEL_COMMIT = "c7c0ba17"
+LOCKED_FORMULAS = ["F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22"]
+
+ARTIFACT_PATHS = (
+    "index.html",
+    "covenant-cockpit.html",
+    "favicon.svg",
+    "app.js",
+    "data.js",
+    "v5_organs.js",
+    "frontier_anatomy.js",
+    "szl-holo-v2.css",
+    "szl-holo-v2.js",
+    "live-body.html",
+    "live-body.js",
+    "covenant-cockpit.js",
+    "lib/three.min.js",
+    "lib/szl_verify_widget.js",
+    "v6_alive.js",
+    "yachay-second-brain.js",
+    "server.py",
+    "hf-deploy-manifest.json",
+)
+
+FORMULA_LINKS = {
+    "locked_spine": "https://github.com/szl-holdings/lutar-lean/tree/main/Lutar/Puriq/Formulas",
+    "proved_formulas": "https://github.com/szl-holdings/lutar-lean/blob/main/Lutar/Puriq/Formulas/ProvedFormulas.lean",
+    "puriq_formula": "https://github.com/szl-holdings/lutar-lean/blob/main/Lutar/Puriq/Formulas/PuriqFormulaLean.lean",
+    "quorum_safety": "https://github.com/szl-holdings/lutar-lean/blob/main/Lutar/Wave23/QuorumSafety.lean",
+    "hash_chain": "https://github.com/szl-holdings/lutar-lean/blob/main/Lutar/Wave8/HashChain.lean",
+}
+
+CAPABILITIES = [
+    {
+        "id": "anatomy.atlas",
+        "name": "Living governed-system atlas",
+        "purpose": "Make system ownership, authority boundaries, and receipt flow spatially inspectable.",
+        "try": {"method": "GET", "path": "/", "action": "Open an organ or run the guided tour."},
+        "evidence": {
+            "state": "COMPUTED",
+            "basis": "The self-contained WebGL bundle and its local data model are hashed into the anatomy integrity receipt.",
+        },
+        "limits": [
+            "A visual map is not proof that every depicted remote service is healthy.",
+            "The atlas is read-only and has no actuation authority.",
+        ],
+        "reproduce": {
+            "steps": [
+                "GET /api/anatomy/v1/receipt",
+                "POST its JSON body to /api/anatomy/v1/verify/receipt",
+                "Compare the artifact_set_sha256 and per-file hashes.",
+            ]
+        },
+        "authority_state": "READ_ONLY",
+        "formula_refs": [],
+        "provenance": ["https://github.com/szl-holdings/anatomy"],
+    },
+    {
+        "id": "anatomy.formula-spine",
+        "name": "Formula-to-organ spine",
+        "purpose": "Trace declared formal and experimental formulas to the organs they inform.",
+        "try": {"method": "UI", "path": "/", "action": "Open Formula Atlas or Proofs to organs."},
+        "evidence": {
+            "state": "SNAPSHOT",
+            "basis": "The Space presents source-linked declarations; it does not run the Lean kernel in this container.",
+            "locked_declared": LOCKED_FORMULAS,
+            "kernel_reference": KERNEL_COMMIT,
+        },
+        "limits": [
+            "Exactly eight formulas are declared locked in this snapshot.",
+            "Lambda is Conjecture 1, not a theorem.",
+            "Current source links and the historical kernel reference are shown separately to avoid false revision equivalence.",
+        ],
+        "reproduce": {
+            "steps": [
+                "Open the linked Lean files.",
+                "Pin the intended toolchain and commit in lutar-lean.",
+                "Run lake build and inspect #print axioms before promoting a claim.",
+            ]
+        },
+        "authority_state": "READ_ONLY",
+        "formula_refs": LOCKED_FORMULAS,
+        "provenance": list(FORMULA_LINKS.values()),
+    },
+    {
+        "id": "anatomy.live-lens",
+        "name": "Live organ posture lens",
+        "purpose": "Project current reachability and contract responses from A11OY, Killinchu, and the verifier estate into the body.",
+        "try": {"method": "GET", "path": "/api/anatomy/v1/evidence?refresh=1", "action": "Refresh measured dependencies."},
+        "evidence": {
+            "state": "MIXED",
+            "basis": "Dependency states are measured at request time and kept separate from the static anatomy snapshot.",
+        },
+        "limits": [
+            "HTTP reachability does not certify correctness, freshness, safety, or business performance.",
+            "A dependency can change after observed_at.",
+        ],
+        "reproduce": {"steps": ["GET /api/anatomy/v1/evidence?refresh=1", "Probe each declared URL independently."]},
+        "authority_state": "READ_ONLY",
+        "formula_refs": ["F1", "F7", "F22"],
+        "provenance": [
+            "https://huggingface.co/spaces/SZLHOLDINGS/a11oy",
+            "https://huggingface.co/spaces/SZLHOLDINGS/killinchu",
+            "https://huggingface.co/spaces/SZLHOLDINGS/governed-receipt-verifier",
+        ],
+    },
+    {
+        "id": "anatomy.integrity-receipt",
+        "name": "Local bundle integrity receipt",
+        "purpose": "Turn the deployed anatomy bundle into a replayable, byte-level evidence object.",
+        "try": {"method": "GET", "path": "/api/anatomy/v1/receipt", "action": "Generate the current deterministic receipt."},
+        "evidence": {
+            "state": "COMPUTED",
+            "verification_state": "STRUCTURAL_ONLY",
+            "basis": "SHA-256 is recomputed over every declared artifact and over the canonical receipt body.",
+        },
+        "limits": [
+            "The local receipt is unsigned because the Space has no private signing key.",
+            "STRUCTURAL-ONLY is not a cryptographic identity attestation.",
+        ],
+        "reproduce": {
+            "steps": [
+                "GET /api/anatomy/v1/receipt",
+                "POST the response to /api/anatomy/v1/verify/receipt",
+                "Expect STRUCTURAL-ONLY unless an artifact or digest was changed, in which case expect FAIL.",
+            ]
+        },
+        "authority_state": "READ_ONLY",
+        "formula_refs": ["F1", "F22"],
+        "provenance": [FORMULA_LINKS["hash_chain"]],
+    },
+    {
+        "id": "anatomy.organ-integrity",
+        "name": "Five-organ fail-closed kernel",
+        "purpose": "Prove the body, not the picture: HEART/YUYAY, BRAIN/YACHAY, CIRCULATORY/YAWAR, NERVOUS/OTel, SKELETON/Khipu. Any DOWN organ or a WILLAY veto fail-closes.",
+        "try": {"method": "GET", "path": "/api/anatomy/v1/organs/integrity", "action": "Healthy cycle, then POST {\"zero_heart\":true}."},
+        "evidence": {
+            "state": "COMPUTED",
+            "basis": "Stdlib SHA-256 receipt chain, advisory Λ, canal-partition silhouette. MEASURED NumPy YARQA lives on SZLHOLDINGS/szl-khipu.",
+        },
+        "limits": [
+            "Λ uniqueness remains Conjecture 1 OPEN. proven_trust is false.",
+            "Energy is UNAVAILABLE. Never a fabricated joule.",
+            "Canal leak here is the fail-closed rule, not NumPy YARQA.",
+            "CHECKED ≠ Lean PROVEN. Locked-proven stays exactly 8.",
+        ],
+        "reproduce": {
+            "steps": [
+                "GET /api/anatomy/v1/organs/integrity — expect 5/5 LIVE, verdict ADVISORY_BODY.",
+                "POST {\"zero_heart\":true} — HEART DOWN, body BLOCKED.",
+                "POST {\"fabricate_joule\":true} — NERVOUS DOWN, energy_j stays null.",
+            ]
+        },
+        "authority_state": "READ_ONLY",
+        "formula_refs": ["F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22"],
+        "provenance": [
+            "https://github.com/szl-holdings/szl-organ-integrity",
+            "https://a-11-oy.com/organs/integrity",
+            "https://huggingface.co/spaces/SZLHOLDINGS/szl-khipu",
+        ],
+    },
+    {
+        "id": "anatomy.physics-overlays",
+        "name": "Physics and quantum-bio overlays",
+        "purpose": "Expose bounded exploratory models beside operational and formal layers without confusing them with measurements or locked theorems.",
+        "try": {"method": "UI", "path": "/", "action": "Open Physics, Quantum-bio, or Yarqa layers."},
+        "evidence": {
+            "state": "MODELED",
+            "basis": "The overlays run deterministic local equations and simulations from data.js; they do not ingest calibrated laboratory measurements.",
+        },
+        "limits": [
+            "Modeled is not measured.",
+            "Narrative and proposed claims remain labeled separately from verified formulas.",
+            "No clinical, biological, or quantum-computing performance claim is made.",
+        ],
+        "reproduce": {
+            "steps": [
+                "Inspect the formula card and its evidence label.",
+                "Record the input parameters.",
+                "Re-run the same local overlay and compare its integrity digest.",
+            ]
+        },
+        "authority_state": "READ_ONLY",
+        "formula_refs": ["QB-COH", "QB-PMF", "QB-COMPASS", "QB-Lambda-v5", "AG-LANDAUER"],
+        "provenance": ["https://github.com/szl-holdings/anatomy/blob/main/data.js"],
+    },
+]
+
+DEPENDENCIES = (
+    {
+        "id": "a11oy.honesty",
+        "url": "https://szlholdings-a11oy.hf.space/api/a11oy/v1/honest",
+        "method": "GET",
+        "purpose": "Doctrine and runtime honesty posture",
+        "critical": True,
+    },
+    {
+        "id": "a11oy.public-verifier",
+        "url": "https://szlholdings-a11oy.hf.space/api/a11oy/v1/verify/receipt",
+        "method": "POST",
+        "purpose": "Canonical public DSSE/Khipu receipt-verifier contract",
+        "critical": True,
+    },
+    {
+        "id": "a11oy.organ-integrity",
+        "url": "https://a-11-oy.com/api/a11oy/v1/organs/integrity",
+        "method": "GET",
+        "purpose": "Fail-closed five-organ kernel on the command body",
+        "critical": False,
+    },
+    {
+        "id": "killinchu.experience-manifest",
+        "url": "https://szlholdings-killinchu.hf.space/api/killinchu/v1/experience/manifest",
+        "method": "GET",
+        "purpose": "Killinchu surface and evidence inventory",
+        "critical": False,
+    },
+    {
+        "id": "receipt-verifier.space",
+        "url": "https://szlholdings-governed-receipt-verifier.static.hf.space/",
+        "method": "GET",
+        "purpose": "Standalone browser verifier",
+        "critical": False,
+    },
+)
+
+CONTENT_SECURITY_POLICY = (
+    "default-src 'self'; "
+    "base-uri 'self'; "
+    "object-src 'none'; "
+    "script-src 'self' 'unsafe-inline'; "
+    "style-src 'self' 'unsafe-inline'; "
+    "img-src 'self' data: blob:; "
+    "font-src 'self'; "
+    "connect-src 'self' https://szlholdings-a11oy.hf.space https://a-11-oy.com "
+    "https://szlholdings-killinchu.hf.space https://szlholdings-amaru.hf.space "
+    "https://szlholdings-sentra.hf.space; "
+    "form-action 'self'; "
+    "frame-ancestors 'self' https://huggingface.co https://*.hf.space https://*.huggingface.co "
+    "https://a-11-oy.com https://*.a-11-oy.com https://a11oy.net https://*.a11oy.net"
+)
+
+_probe_lock = threading.Lock()
+_probe_cache: dict[str, object] = {"at": 0.0, "value": None}
+_revision_lock = threading.Lock()
+_revision_cache: dict[str, object] = {"at": 0.0, "value": None}
+_binding_lock = threading.Lock()
+_binding_cache: dict[str, object] = {"at": 0.0, "key": None, "value": False}
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _canonical(value: object) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _artifact_manifest() -> dict[str, object]:
+    artifacts: list[dict[str, object]] = []
+    for rel in ARTIFACT_PATHS:
+        path = DIRECTORY / rel
+        if path.is_file():
+            content = path.read_bytes()
+            artifacts.append({"path": rel, "bytes": len(content), "sha256": _sha256(content)})
+        else:
+            artifacts.append({"path": rel, "state": "MISSING"})
+    artifact_set_sha256 = _sha256(_canonical(artifacts))
+    return {
+        "algorithm": "sha256",
+        "artifact_count": len(artifacts),
+        "artifact_set_sha256": artifact_set_sha256,
+        "artifacts": artifacts,
+    }
+
+
+def _artifact_set_complete(manifest: object) -> bool:
+    if not isinstance(manifest, dict):
+        return False
+    artifacts = manifest.get("artifacts")
+    if not isinstance(artifacts, list) or len(artifacts) != len(ARTIFACT_PATHS):
+        return False
+    paths: list[str] = []
+    for item in artifacts:
+        if (
+            not isinstance(item, dict)
+            or not isinstance(item.get("path"), str)
+            or not isinstance(item.get("bytes"), int)
+            or int(item["bytes"]) <= 0
+            or not _is_sha256(item.get("sha256"))
+        ):
+            return False
+        paths.append(str(item["path"]))
+    return len(set(paths)) == len(paths) and set(paths) == set(ARTIFACT_PATHS)
+
+
+def _artifact_manifest_digest_valid(manifest: object) -> bool:
+    if not isinstance(manifest, dict) or not isinstance(manifest.get("artifacts"), list):
+        return False
+    return _sha256(_canonical(manifest["artifacts"])) == manifest.get("artifact_set_sha256")
+
+
+def _local_receipt() -> dict[str, object]:
+    manifest = _artifact_manifest()
+    artifact_complete = _artifact_set_complete(manifest) and _artifact_manifest_digest_valid(manifest)
+    body: dict[str, object] = {
+        "schema": "szl.anatomy-integrity-receipt/v1",
+        "subject": {
+            "space": SPACE_ID,
+            "artifact_set_sha256": manifest["artifact_set_sha256"],
+        },
+        "claim": {
+            "purpose": "Byte-level integrity of the deployed Living Anatomy bundle",
+            "authority_state": "READ_ONLY",
+            "evidence_state": "COMPUTED" if artifact_complete else "UNAVAILABLE",
+            "doctrine": DOCTRINE,
+            "kernel_reference": KERNEL_COMMIT,
+            "locked_proven_declared": len(LOCKED_FORMULAS),
+            "lambda_state": "CONJECTURE_1",
+        },
+        "evidence": manifest,
+        "signature": {
+            "state": "UNAVAILABLE",
+            "reason": "No private signing key is present in this public visualization Space.",
+        },
+        "limits": [
+            "Artifact integrity does not certify remote-service health or model quality.",
+            "Unsigned local receipt; verification is STRUCTURAL-ONLY.",
+        ],
+    }
+    return {
+        "receipt": body,
+        "receipt_id": _sha256(_canonical(body)),
+        "verification_state": "STRUCTURAL_ONLY" if artifact_complete else "FAILED",
+    }
+
+
+def _check_local_receipt(candidate: object) -> tuple[int, dict[str, object]]:
+    wrapper = candidate if isinstance(candidate, dict) else {}
+    receipt = wrapper.get("receipt", wrapper) if isinstance(wrapper, dict) else {}
+    supplied_id = wrapper.get("receipt_id") if isinstance(wrapper, dict) else None
+    if not isinstance(receipt, dict):
+        receipt = {}
+
+    current = _artifact_manifest()
+    recomputed_id = _sha256(_canonical(receipt))
+    subject = receipt.get("subject") if isinstance(receipt.get("subject"), dict) else {}
+    evidence = receipt.get("evidence") if isinstance(receipt.get("evidence"), dict) else {}
+    current_complete = _artifact_set_complete(current) and _artifact_manifest_digest_valid(current)
+    candidate_complete = _artifact_set_complete(evidence) and _artifact_manifest_digest_valid(evidence)
+    checks = [
+        {
+            "name": "schema",
+            "status": "PASS" if receipt.get("schema") == "szl.anatomy-integrity-receipt/v1" else "FAIL",
+            "detail": "Expected szl.anatomy-integrity-receipt/v1.",
+        },
+        {
+            "name": "subject",
+            "status": "PASS" if subject.get("space") == SPACE_ID else "FAIL",
+            "detail": f"Expected {SPACE_ID}.",
+        },
+        {
+            "name": "receipt_digest",
+            "status": "PASS" if supplied_id and supplied_id == recomputed_id else "FAIL",
+            "detail": "SHA-256 over the canonical receipt body.",
+        },
+        {
+            "name": "artifact_set",
+            "status": "PASS"
+            if current_complete
+            and candidate_complete
+            and evidence.get("artifact_set_sha256") == current["artifact_set_sha256"]
+            and subject.get("artifact_set_sha256") == current["artifact_set_sha256"]
+            else "FAIL",
+            "detail": "Recomputed from both the submitted evidence and files currently served by this Space.",
+        },
+        {
+            "name": "artifact_completeness",
+            "status": "PASS"
+            if current_complete and candidate_complete
+            else "FAIL",
+            "detail": "Both the submitted and currently served manifests must contain every non-empty runtime artifact and bind their artifact-list digest.",
+        },
+        {
+            "name": "signature",
+            "status": "UNAVAILABLE",
+            "detail": "This local integrity receipt is unsigned; no cryptographic identity green is asserted.",
+        },
+    ]
+    failed = any(item["status"] == "FAIL" for item in checks)
+    verdict = "FAIL" if failed else "STRUCTURAL-ONLY"
+    return (400 if failed else 200), {
+        "schema": "szl.receipt-verification/v1",
+        "ok": not failed,
+        "verdict": verdict,
+        "verification_state": "FAILED" if failed else "STRUCTURAL_ONLY",
+        "checks": checks,
+        "recomputed_receipt_id": recomputed_id,
+        "observed_at": _utc_now(),
+        "limits": "STRUCTURAL-ONLY is advisory and is not a signature verification.",
+    }
+
+
+def _probe_dependency(dep: dict[str, object]) -> dict[str, object]:
+    method = str(dep["method"])
+    data = b"{}" if method == "POST" else None
+    headers = {
+        "User-Agent": "szl-anatomy-evidence/1.0",
+        "Accept": "application/json,text/html;q=0.8",
+    }
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(str(dep["url"]), data=data, headers=headers, method=method)
+    status: int | None = None
+    error: str | None = None
+    try:
+        with urllib.request.urlopen(req, timeout=4) as response:
+            status = response.status
+            response.read(256)
+    except urllib.error.HTTPError as exc:
+        status = exc.code
+        error = f"HTTP {exc.code}"
+    except Exception as exc:  # network state is evidence, not a server failure
+        error = type(exc).__name__
+
+    reachable = status is not None
+    if method == "POST":
+        contract_available = status in (200, 201, 400, 422, 429)
+    else:
+        contract_available = status is not None and 200 <= status < 400
+    if contract_available:
+        contract_state = "AVAILABLE"
+        evidence_state = "LIVE"
+    elif status == 404:
+        contract_state = "MISSING"
+        evidence_state = "UNAVAILABLE"
+    elif reachable:
+        contract_state = "DEGRADED"
+        evidence_state = "UNAVAILABLE"
+    else:
+        contract_state = "UNREACHABLE"
+        evidence_state = "UNAVAILABLE"
+    return {
+        **dep,
+        "transport_state": "REACHABLE" if reachable else "UNREACHABLE",
+        "contract_state": contract_state,
+        "evidence_state": evidence_state,
+        "http_status": status,
+        "error": error,
+    }
+
+
+def _dependency_evidence(force: bool = False) -> dict[str, object]:
+    now = time.monotonic()
+    with _probe_lock:
+        cached = _probe_cache.get("value")
+        if not force and cached is not None and now - float(_probe_cache["at"]) < 30:
+            return cached  # type: ignore[return-value]
+    with ThreadPoolExecutor(max_workers=len(DEPENDENCIES)) as pool:
+        rows = list(pool.map(_probe_dependency, DEPENDENCIES))
+    live_count = sum(row["evidence_state"] == "LIVE" for row in rows)
+    evidence_state = "LIVE" if live_count == len(rows) else ("MIXED" if live_count else "UNAVAILABLE")
+    verifier = next(row for row in rows if row["id"] == "a11oy.public-verifier")
+    value: dict[str, object] = {
+        "schema": "szl.anatomy-evidence/v1",
+        "observed_at": _utc_now(),
+        "scope": "Endpoint reachability and declared contract presence only.",
+        "transport_state": "REACHABLE",
+        "evidence_state": evidence_state,
+        "verification_state": "AVAILABLE" if verifier["contract_state"] == "AVAILABLE" else "UNAVAILABLE",
+        "authority_state": "READ_ONLY",
+        "summary": {"live": live_count, "total": len(rows)},
+        "dependencies": rows,
+        "limits": [
+            "Reachability does not certify quality, safety, freshness, or business performance.",
+            "The local anatomy integrity verifier remains STRUCTURAL_ONLY because it is unsigned.",
+        ],
+    }
+    with _probe_lock:
+        _probe_cache.update({"at": time.monotonic(), "value": value})
+    return value
+
+
+def _is_full_revision(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == 40
+        and all(character in "0123456789abcdef" for character in value.lower())
+    )
+
+
+def _is_sha256(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == 64
+        and all(character in "0123456789abcdef" for character in value.lower())
+    )
+
+
+def _hf_revision(force: bool = False) -> str | None:
+    env_revision = os.environ.get("SPACE_REPOSITORY_COMMIT")
+    if _is_full_revision(env_revision):
+        return str(env_revision).lower()
+    now = time.monotonic()
+    with _revision_lock:
+        cached = _revision_cache.get("value")
+        if not force and cached and now - float(_revision_cache["at"]) < 60:
+            return str(cached)
+    req = urllib.request.Request(
+        "https://huggingface.co/api/spaces/betterwithage/anatomy?expand[]=sha",
+        headers={"User-Agent": "szl-anatomy-source-attestation/1.0", "Accept": "application/json"},
+    )
+    revision: str | None = None
+    try:
+        with urllib.request.urlopen(req, timeout=4) as response:
+            data = json.load(response)
+            candidate = data.get("sha")
+            if _is_full_revision(candidate):
+                revision = str(candidate).lower()
+    except Exception:
+        revision = None
+    with _revision_lock:
+        _revision_cache.update({"at": time.monotonic(), "value": revision})
+    return revision
+
+
+def _hf_commit_matches_source(
+    revision: object,
+    source_revision: object,
+    workflow_run_id: object,
+    force: bool = False,
+) -> bool:
+    if (
+        not _is_full_revision(revision)
+        or not _is_full_revision(source_revision)
+        or not isinstance(workflow_run_id, str)
+        or not workflow_run_id.isdigit()
+    ):
+        return False
+    revision = str(revision).lower()
+    source_revision = str(source_revision).lower()
+    key = f"{revision}:{source_revision}:{workflow_run_id}"
+    now = time.monotonic()
+    with _binding_lock:
+        if (
+            not force
+            and _binding_cache.get("key") == key
+            and now - float(_binding_cache["at"]) < 60
+        ):
+            return bool(_binding_cache["value"])
+
+    expected_title = f"hf-sync: source {source_revision} run {workflow_run_id}"
+    commits_request = urllib.request.Request(
+        "https://huggingface.co/api/spaces/betterwithage/anatomy/commits/main?limit=1",
+        headers={"User-Agent": "szl-anatomy-source-attestation/1.1", "Accept": "application/json"},
+    )
+    diff_request = urllib.request.Request(
+        f"https://huggingface.co/spaces/betterwithage/anatomy/commit/{revision}.diff",
+        headers={"User-Agent": "szl-anatomy-source-attestation/1.1", "Accept": "text/plain"},
+    )
+    manifest_request = urllib.request.Request(
+        "https://huggingface.co/spaces/betterwithage/anatomy/resolve/"
+        f"{revision}/hf-deploy-manifest.json",
+        headers={"User-Agent": "szl-anatomy-source-attestation/1.1", "Accept": "application/json"},
+    )
+    matched = False
+    try:
+        with urllib.request.urlopen(commits_request, timeout=4) as response:
+            commits = json.load(response)
+        with urllib.request.urlopen(diff_request, timeout=4) as response:
+            commit_diff = response.read(1_000_000).decode("utf-8")
+        with urllib.request.urlopen(manifest_request, timeout=4) as response:
+            deployed_manifest = json.loads(response.read(100_000).decode("utf-8"))
+        latest = commits[0] if isinstance(commits, list) and commits else {}
+        matched = (
+            isinstance(latest, dict)
+            and str(latest.get("id") or "").lower() == revision
+            and latest.get("title") == expected_title
+            and "diff --git a/hf-deploy-manifest.json b/hf-deploy-manifest.json" in commit_diff
+            and isinstance(deployed_manifest, dict)
+            and deployed_manifest.get("schema") == "szl.hf-deploy-manifest/v1"
+            and deployed_manifest.get("source_repository") == SOURCE_REPOSITORY
+            and str(deployed_manifest.get("source_revision") or "").lower() == source_revision
+            and deployed_manifest.get("workflow_run_id") == workflow_run_id
+        )
+    except Exception:
+        matched = False
+    with _binding_lock:
+        _binding_cache.update({"at": time.monotonic(), "key": key, "value": matched})
+    return matched
+
+
+def _source_binding() -> dict[str, object]:
+    fallback: dict[str, object] = {
+        "repository": SOURCE_REPOSITORY,
+        "commit": SOURCE_BASE_COMMIT,
+        "path": "",
+        "relation": "base-plus-hf-overlay",
+        "alignment_state": "PENDING_GITHUB_SYNC",
+        "workflow_run_id": None,
+        "built_at": None,
+        "limits": [
+            "source.commit is the declared GitHub base; deployment.hf_revision is measured separately.",
+            "No workflow-generated deployment manifest was observed.",
+        ],
+    }
+    try:
+        payload = json.loads(DEPLOY_MANIFEST_PATH.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return fallback
+    repository = payload.get("source_repository")
+    revision = payload.get("source_revision")
+    workflow_run_id = payload.get("workflow_run_id")
+    if (
+        payload.get("schema") != "szl.hf-deploy-manifest/v1"
+        or repository != SOURCE_REPOSITORY
+        or not _is_full_revision(revision)
+        or not isinstance(workflow_run_id, str)
+        or not workflow_run_id.isdigit()
+    ):
+        return fallback
+    return {
+        "repository": repository,
+        "commit": revision.lower(),
+        "path": str(payload.get("source_path") or ""),
+        "relation": "github-actions-source-bound-deployment",
+        "alignment_state": "SOURCE_BOUND_DEPLOYMENT",
+        "workflow_run_id": workflow_run_id,
+        "built_at": payload.get("built_at"),
+        "limits": [
+            "The manifest binds this Hugging Face revision to the GitHub commit used by the deployment workflow.",
+            "The deployment uploads a declared runtime whitelist; it does not claim whole-repository byte parity.",
+        ],
+    }
+
+
+def _source_attestation(force: bool = False) -> dict[str, object]:
+    revision = _hf_revision(force=force)
+    manifest = _artifact_manifest()
+    source_binding = _source_binding()
+    manifest_source_revision = source_binding.get("commit")
+    workflow_run_id = source_binding.get("workflow_run_id")
+    revision_bound = (
+        source_binding["alignment_state"] == "SOURCE_BOUND_DEPLOYMENT"
+        and _hf_commit_matches_source(
+            revision, manifest_source_revision, workflow_run_id, force=force
+        )
+    )
+    alignment_state = source_binding["alignment_state"]
+    limits = list(source_binding["limits"])
+    if alignment_state == "SOURCE_BOUND_DEPLOYMENT" and not revision_bound:
+        alignment_state = "DEPLOYMENT_REVISION_UNBOUND"
+        limits.append(
+            "The current Hugging Face commit metadata and diff do not bind this manifest to the measured deployment revision."
+        )
+    return {
+        "schema": "szl.deployment-source/v1",
+        "source": {
+            key: source_binding[key]
+            for key in ("repository", "commit", "path", "relation")
+        },
+        "deployment": {
+            "hf_space": SPACE_ID,
+            "hf_revision": revision,
+            "artifact_set_sha256": manifest["artifact_set_sha256"],
+            "commit_binding": "MEASURED" if revision_bound else "UNAVAILABLE",
+            "workflow_run_id": workflow_run_id if revision_bound else None,
+        },
+        "built_at": source_binding["built_at"],
+        "observed_at": _utc_now(),
+        "alignment_state": alignment_state,
+        "limits": limits,
+    }
+
+
+def _version_contract(force: bool = False) -> dict[str, object]:
+    source = _source_attestation(force=force)
+    source_identity = source["source"]
+    deployment = source["deployment"]
+    identity_measured = (
+        source["alignment_state"] == "SOURCE_BOUND_DEPLOYMENT"
+        and isinstance(source_identity, dict)
+        and _is_full_revision(source_identity.get("commit"))
+        and isinstance(deployment, dict)
+        and _is_full_revision(deployment.get("hf_revision"))
+    )
+    return {
+        "schemaVersion": "szl.vertical-conformance.version.v1",
+        "service": "anatomy",
+        "surface": "anatomy",
+        "gitSha": source_identity.get("commit") if identity_measured else None,
+        "evidenceState": "MEASURED" if identity_measured else "UNAVAILABLE",
+        "deploymentRevision": deployment.get("hf_revision") if isinstance(deployment, dict) else None,
+        "contractVersion": "1.1.0",
+    }
+
+
+def _evidence_contract(force: bool = False) -> dict[str, object]:
+    source = _source_attestation(force=force)
+    dependency_evidence = _dependency_evidence(force=force)
+    local_receipt = _local_receipt()
+    source_identity = source["source"]
+    deployment = source["deployment"]
+    source_bound = (
+        source["alignment_state"] == "SOURCE_BOUND_DEPLOYMENT"
+        and isinstance(source_identity, dict)
+        and _is_full_revision(source_identity.get("commit"))
+        and isinstance(deployment, dict)
+        and _is_full_revision(deployment.get("hf_revision"))
+    )
+    receipt_body = local_receipt["receipt"]
+    receipt_evidence = receipt_body["evidence"] if isinstance(receipt_body, dict) else {}
+    artifact_complete = _artifact_set_complete(receipt_evidence)
+    evidence_available = source_bound and artifact_complete
+    return {
+        "schemaVersion": "szl.vertical-conformance.evidence.v1",
+        "service": "anatomy",
+        "surface": "anatomy",
+        "gitSha": source_identity.get("commit") if evidence_available else None,
+        "evidenceState": "PARTIAL" if evidence_available else "UNAVAILABLE",
+        "runtime": {
+            "status": "RUNNING" if artifact_complete else "DEGRADED",
+            "ready": artifact_complete,
+            "transportState": "REACHABLE",
+            "authorityState": "READ_ONLY",
+        },
+        "source": source,
+        "receipts": [
+            {
+                "kind": "bundle-integrity",
+                "status": "STRUCTURAL_ONLY" if artifact_complete else "FAILED",
+                "receiptId": local_receipt["receipt_id"],
+                "artifactSetSha256": (
+                    receipt_evidence.get("artifact_set_sha256")
+                    if isinstance(receipt_evidence, dict)
+                    else None
+                ),
+                "scope": "deployed runtime whitelist; unsigned local recomputation",
+                "verify": "/api/anatomy/v1/verify/receipt",
+            }
+        ],
+        "dependencies": {
+            "evidenceState": dependency_evidence["evidence_state"],
+            "observedAt": dependency_evidence["observed_at"],
+            "live": dependency_evidence["summary"]["live"],
+            "total": dependency_evidence["summary"]["total"],
+            "details": "/api/anatomy/v1/evidence?refresh=1",
+        },
+        "outputProvenance": {
+            "signatureStatus": "UNSIGNED",
+            "authenticityEstablished": False,
+            "record": "content-addressed bundle receipt; no runtime signing key",
+        },
+        "limitations": [
+            "The bundle receipt is STRUCTURAL_ONLY and does not establish publisher identity.",
+            "Dependency reachability does not certify quality, safety, freshness, or business performance.",
+            "The Space is read-only and does not execute or authorize agent actions.",
+        ],
+    }
+
+
+def _manifest() -> dict[str, object]:
+    return {
+        "schema": "szl.anatomy-manifest/v1",
+        "service": "anatomy-space",
+        "space": SPACE_ID,
+        "purpose": "Read-only spatial evidence map of the governed-agent substrate.",
+        "contract_version": "1.1.0",
+        "state_dimensions": {
+            "transport_state": "REACHABLE",
+            "evidence_state": "MIXED",
+            "verification_state": "STRUCTURAL_ONLY",
+            "authority_state": "READ_ONLY",
+        },
+        "status_vocabulary": {
+            "transport_state": ["REACHABLE", "UNREACHABLE"],
+            "evidence_state": ["LIVE", "COMPUTED", "SNAPSHOT", "MODELED", "MIXED", "UNAVAILABLE"],
+            "verification_state": ["VERIFIED", "STRUCTURAL_ONLY", "UNAVAILABLE", "FAILED"],
+            "authority_state": ["READ_ONLY", "PROPOSAL_ONLY", "MUTATING"],
+        },
+        "endpoints": {
+            "version": "/version",
+            "evidence_index": "/evidence",
+            "manifest": "/api/anatomy/v1/manifest",
+            "capabilities": "/api/anatomy/v1/capabilities",
+            "evidence": "/api/anatomy/v1/evidence?refresh=1",
+            "receipt": "/api/anatomy/v1/receipt",
+            "verify_receipt": "/api/anatomy/v1/verify/receipt",
+            "organ_integrity": "/api/anatomy/v1/organs/integrity",
+            "source": "/.well-known/szl-source.json",
+        },
+        "doctrine": {
+            "version": DOCTRINE,
+            "lock": LOCK,
+            "kernel_reference": KERNEL_COMMIT,
+            "locked_proven_declared": LOCKED_FORMULAS,
+            "lambda": "CONJECTURE_1",
+        },
+        "limits": [
+            "RUNNING or REACHABLE describes transport, not model quality.",
+            "This Space is a visualization and evidence reader, not an autonomous actuator.",
+        ],
+    }
+
+
+class HardenedHandler(SimpleHTTPRequestHandler):
+    server_version = "szl"
+    sys_version = ""
+
+    def version_string(self) -> str:
+        return "szl"
+
+    def _send_json(
+        self,
+        payload: object,
+        *,
+        status: int = 200,
+        evidence_state: str = "SNAPSHOT",
+        extra_headers: dict[str, str] | None = None,
+    ) -> None:
+        body = json.dumps(payload, ensure_ascii=False, sort_keys=True).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("X-SZL-Transport-State", "REACHABLE")
+        self.send_header("X-SZL-Evidence-State", evidence_state)
+        if extra_headers:
+            for key, value in extra_headers.items():
+                self.send_header(key, value)
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_OPTIONS(self) -> None:  # noqa: N802
+        self.send_response(204)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.send_header("Access-Control-Max-Age", "600")
+        self.end_headers()
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urlsplit(self.path)
+        path = parsed.path
+        query = parse_qs(parsed.query)
+        force = query.get("refresh") == ["1"]
+        if path == "/healthz":
+            self._send_json(
+                {
+                    "status": "ok",
+                    "organ": "anatomy",
+                    "service": "anatomy-space",
+                    "transport_state": "REACHABLE",
+                    "evidence_state": "SNAPSHOT",
+                    "verification_state": "STRUCTURAL_ONLY",
+                    "authority_state": "READ_ONLY",
+                    "contracts": {"version": "/version", "evidence": "/evidence"},
+                    "note": "Transport health only; quality and upstream freshness are not inferred.",
+                },
+                evidence_state="SNAPSHOT",
+            )
+            return
+        if path == "/version":
+            payload = _version_contract(force=force)
+            self._send_json(
+                payload,
+                status=200 if payload["evidenceState"] == "MEASURED" else 503,
+                evidence_state=str(payload["evidenceState"]),
+            )
+            return
+        if path == "/evidence":
+            payload = _evidence_contract(force=force)
+            receipt_status = str(payload["receipts"][0]["status"])
+            self._send_json(
+                payload,
+                status=200 if payload["evidenceState"] == "PARTIAL" else 503,
+                evidence_state=str(payload["evidenceState"]),
+                extra_headers={"X-SZL-Verification-State": receipt_status},
+            )
+            return
+        if path == "/.well-known/szl-source.json":
+            self._send_json(_source_attestation(force=force), evidence_state="COMPUTED")
+            return
+        if path == "/api/anatomy/v1/manifest":
+            self._send_json(_manifest(), evidence_state="SNAPSHOT")
+            return
+        if path in ("/api/anatomy/v1/capabilities", "/api/anatomy/v1/capability-matrix"):
+            self._send_json(
+                {
+                    "schema": "szl.anatomy-capabilities/v1",
+                    "state_dimensions": _manifest()["state_dimensions"],
+                    "count": len(CAPABILITIES),
+                    "capabilities": CAPABILITIES,
+                },
+                evidence_state="MIXED",
+            )
+            return
+        if path == "/api/anatomy/v1/evidence":
+            payload = _dependency_evidence(force=force)
+            self._send_json(payload, evidence_state=str(payload["evidence_state"]))
+            return
+        if path == "/api/anatomy/v1/receipt":
+            payload = _local_receipt()
+            verification_state = str(payload["verification_state"])
+            self._send_json(
+                payload,
+                status=200 if verification_state == "STRUCTURAL_ONLY" else 503,
+                evidence_state=("COMPUTED" if verification_state == "STRUCTURAL_ONLY" else "UNAVAILABLE"),
+                extra_headers={"X-SZL-Verification-State": verification_state},
+            )
+            return
+        if path in ("/api/anatomy/v1/organs/integrity", "/api/organs/integrity"):
+            if not _ORGAN_INTEGRITY:
+                self._send_json(
+                    {"ok": False, "error": "organ-integrity kernel UNAVAILABLE"},
+                    status=503,
+                    evidence_state="UNAVAILABLE",
+                )
+                return
+            flags = _org_parse_flags(query)
+            payload = _org_envelope(_evaluate_anatomy(**flags))
+            ev = payload.get("body") if isinstance(payload, dict) else {}
+            blocked = bool(ev.get("blocked")) if isinstance(ev, dict) else False
+            self._send_json(
+                payload,
+                evidence_state="COMPUTED",
+                extra_headers={"X-SZL-Organ-Verdict": "BLOCKED" if blocked else "ADVISORY_BODY"},
+            )
+            return
+        super().do_GET()
+
+    def do_POST(self) -> None:  # noqa: N802
+        path = urlsplit(self.path).path
+        if path in ("/api/anatomy/v1/organs/integrity", "/api/organs/integrity"):
+            if not _ORGAN_INTEGRITY:
+                self._send_json(
+                    {"ok": False, "error": "organ-integrity kernel UNAVAILABLE"},
+                    status=503,
+                    evidence_state="UNAVAILABLE",
+                )
+                return
+            try:
+                length = int(self.headers.get("Content-Length", "0"))
+            except ValueError:
+                length = 0
+            data: dict = {}
+            if 0 < length <= 1_000_000:
+                try:
+                    parsed = json.loads(self.rfile.read(length))
+                    if isinstance(parsed, dict):
+                        data = parsed
+                except Exception:
+                    data = {}
+            flags = _org_parse_flags(data)
+            payload = _org_envelope(_evaluate_anatomy(**flags))
+            ev = payload.get("body") if isinstance(payload, dict) else {}
+            blocked = bool(ev.get("blocked")) if isinstance(ev, dict) else False
+            self._send_json(
+                payload,
+                evidence_state="COMPUTED",
+                extra_headers={"X-SZL-Organ-Verdict": "BLOCKED" if blocked else "ADVISORY_BODY"},
+            )
+            return
+        if path != "/api/anatomy/v1/verify/receipt":
+            self._send_json({"error": "not_found", "path": path}, status=404, evidence_state="UNAVAILABLE")
+            return
+        try:
+            length = int(self.headers.get("Content-Length", "0"))
+        except ValueError:
+            length = 0
+        if length <= 0 or length > 1_000_000:
+            self._send_json(
+                {"error": "invalid_body", "detail": "JSON body required; maximum 1,000,000 bytes."},
+                status=400,
+                evidence_state="UNAVAILABLE",
+            )
+            return
+        try:
+            candidate = json.loads(self.rfile.read(length))
+        except Exception:
+            self._send_json({"error": "invalid_json"}, status=400, evidence_state="UNAVAILABLE")
+            return
+        status, payload = _check_local_receipt(candidate)
+        self._send_json(
+            payload,
+            status=status,
+            evidence_state="COMPUTED",
+            extra_headers={"X-SZL-Verification-State": str(payload["verification_state"])},
+        )
+
+    def end_headers(self) -> None:
+        self.send_header("Cross-Origin-Opener-Policy", "same-origin-allow-popups")
+        self.send_header("Cross-Origin-Resource-Policy", "cross-origin")
+        self.send_header("Content-Security-Policy", CONTENT_SECURITY_POLICY)
+        self.send_header("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("Referrer-Policy", "strict-origin-when-cross-origin")
+        self.send_header("Permissions-Policy", "camera=(), microphone=(), geolocation=(), payment=()")
+        super().end_headers()
+
+
+def make_server(host: str = "0.0.0.0", port: int = PORT) -> ThreadingHTTPServer:
+    handler = functools.partial(HardenedHandler, directory=str(DIRECTORY))
+    return ThreadingHTTPServer((host, port), handler)
+
+
+if __name__ == "__main__":
+    httpd = make_server()
+    print(f"Serving SZL Living Anatomy from {DIRECTORY} on 0.0.0.0:{PORT}", flush=True)
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        httpd.server_close()

style.css

@@ -0,0 +1,28 @@
+body {
+	padding: 2rem;
+	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
+}
+
+h1 {
+	font-size: 16px;
+	margin-top: 0;
+}
+
+p {
+	color: rgb(107, 114, 128);
+	font-size: 15px;
+	margin-bottom: 10px;
+	margin-top: 5px;
+}
+
+.card {
+	max-width: 620px;
+	margin: 0 auto;
+	padding: 16px;
+	border: 1px solid lightgray;
+	border-radius: 16px;
+}
+
+.card p:last-child {
+	margin-bottom: 0;
+}

szl-holo-v2.css

@@ -0,0 +1,720 @@
+/*
+ * A11oy Holo-Constellation v2.0.0
+ * SZL-original visual material and interaction system.
+ * No external assets, tracking, storage, network fetches, or copied design code.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+:root {
+  --szl-holo-bg: #050806;
+  --szl-holo-bg-deep: #020403;
+  --szl-holo-surface: #0c1513;
+  --szl-holo-surface-2: #14201d;
+  --szl-holo-ink: #f3fff8;
+  --szl-holo-muted: #9fb7ad;
+  --szl-holo-accent: #b8ff45;
+  --szl-holo-accent-2: #31e6d1;
+  --szl-holo-danger: #ff625b;
+  --szl-holo-warning: #e2bb6d;
+  --szl-holo-success: #76d8aa;
+  --szl-holo-line: color-mix(in srgb, var(--szl-holo-accent) 20%, transparent);
+  --szl-holo-line-soft: color-mix(in srgb, var(--szl-holo-ink) 10%, transparent);
+  --szl-holo-glow: color-mix(in srgb, var(--szl-holo-accent) 16%, transparent);
+  --szl-holo-glow-2: color-mix(in srgb, var(--szl-holo-accent-2) 12%, transparent);
+  --szl-holo-shadow: 0 24px 84px rgb(0 0 0 / 0.42);
+  --szl-holo-radius-sm: 10px;
+  --szl-holo-radius-md: 18px;
+  --szl-holo-radius-lg: 30px;
+  --szl-holo-radius-xl: 44px;
+  --szl-holo-space-1: clamp(.45rem, .35rem + .3vw, .7rem);
+  --szl-holo-space-2: clamp(.8rem, .65rem + .5vw, 1.2rem);
+  --szl-holo-space-3: clamp(1.2rem, .95rem + .8vw, 1.9rem);
+  --szl-holo-space-4: clamp(1.8rem, 1.25rem + 1.7vw, 3.4rem);
+  --szl-holo-space-5: clamp(2.8rem, 2rem + 3vw, 6rem);
+  --szl-holo-pointer-x: 50%;
+  --szl-holo-pointer-y: 22%;
+  --szl-holo-scroll: 0;
+  --szl-holo-tilt-x: 0deg;
+  --szl-holo-tilt-y: 0deg;
+  --szl-holo-rail-height: 58px;
+  --szl-holo-z-ambient: -2;
+  --szl-holo-z-rail: 2147483000;
+  color-scheme: dark;
+  accent-color: var(--szl-holo-accent);
+}
+
+html[data-szl-holo="v2"] {
+  min-height: 100%;
+  overflow-x: clip;
+  background: var(--szl-holo-bg-deep);
+  scrollbar-color: color-mix(in srgb, var(--szl-holo-accent) 42%, transparent) var(--szl-holo-bg-deep);
+  scroll-padding-top: calc(var(--szl-holo-rail-height) + 18px);
+}
+
+html[data-szl-holo="v2"] body {
+  min-height: 100%;
+  overflow-x: clip;
+  color: var(--szl-holo-ink);
+  background: transparent;
+}
+
+html[data-szl-holo="v2"] body::before {
+  position: fixed;
+  inset: 0;
+  z-index: calc(var(--szl-holo-z-ambient) - 1);
+  pointer-events: none;
+  content: "";
+  background:
+    radial-gradient(circle at var(--szl-holo-pointer-x) var(--szl-holo-pointer-y), var(--szl-holo-glow), transparent 24rem),
+    radial-gradient(circle at 90% 8%, var(--szl-holo-glow-2), transparent 30rem),
+    linear-gradient(158deg, var(--szl-holo-bg), color-mix(in srgb, var(--szl-holo-bg) 84%, var(--szl-holo-surface)) 58%, var(--szl-holo-bg-deep));
+}
+
+/* Lightweight optical texture. It is decorative and does not represent telemetry. */
+html[data-szl-holo="v2"] body::after {
+  position: fixed;
+  inset: 0;
+  z-index: calc(var(--szl-holo-z-ambient) - 1);
+  pointer-events: none;
+  content: "";
+  opacity: .14;
+  background-image:
+    repeating-linear-gradient(0deg, transparent 0 3px, rgb(255 255 255 / .018) 4px),
+    repeating-linear-gradient(90deg, transparent 0 5px, rgb(255 255 255 / .012) 6px);
+  mix-blend-mode: soft-light;
+}
+
+#szl-holo-ambient {
+  position: fixed;
+  inset: 0;
+  z-index: var(--szl-holo-z-ambient);
+  overflow: hidden;
+  pointer-events: none;
+  contain: strict;
+  opacity: .82;
+}
+
+#szl-holo-ambient::before,
+#szl-holo-ambient::after {
+  position: absolute;
+  inset: -18%;
+  content: "";
+  transform-origin: center;
+  will-change: transform;
+}
+
+/* Command constellation: orbital paths over a tactical field. */
+html[data-szl-holo-motif="command-constellation"] #szl-holo-ambient::before {
+  background:
+    radial-gradient(circle at center, var(--szl-holo-accent) 0 1.5px, transparent 2.5px),
+    linear-gradient(var(--szl-holo-line) 1px, transparent 1px),
+    linear-gradient(90deg, var(--szl-holo-line) 1px, transparent 1px);
+  background-size: 112px 112px, 56px 56px, 56px 56px;
+  mask-image: radial-gradient(ellipse at 63% 29%, #000 0 18%, transparent 70%);
+  transform: perspective(720px) rotateX(58deg) translate3d(0, 22%, 0) scale(1.12);
+}
+
+html[data-szl-holo-motif="command-constellation"] #szl-holo-ambient::after {
+  inset: 4% -10% -28% 34%;
+  border: 1px solid var(--szl-holo-line);
+  border-radius: 50%;
+  background:
+    repeating-radial-gradient(ellipse, transparent 0 74px, var(--szl-holo-line) 75px 76px),
+    conic-gradient(from 218deg, transparent 0 72%, var(--szl-holo-glow) 74% 75.5%, transparent 77%);
+  transform: rotate(-9deg) scaleY(.58);
+  animation: szl-holo-orbit 38s linear infinite;
+}
+
+/* Observability: living signals and anomaly ribbons. */
+html[data-szl-holo-motif="signal-aurora"] #szl-holo-ambient::before {
+  inset: -46% -15%;
+  border-radius: 50%;
+  background: conic-gradient(from 76deg, transparent, var(--szl-holo-glow), transparent 25%, color-mix(in srgb, var(--szl-holo-accent-2) 18%, transparent), transparent 62%);
+  filter: blur(44px) saturate(125%);
+  animation: szl-holo-aurora 22s ease-in-out infinite alternate;
+}
+
+html[data-szl-holo-motif="signal-aurora"] #szl-holo-ambient::after {
+  background:
+    repeating-linear-gradient(90deg, transparent 0 43px, var(--szl-holo-line) 44px, transparent 45px 82px),
+    linear-gradient(170deg, transparent 38%, var(--szl-holo-glow-2) 39% 40%, transparent 41% 58%, var(--szl-holo-glow) 59% 60%, transparent 61%);
+  mask-image: linear-gradient(transparent, #000 28% 78%, transparent 92%);
+  transform: skewY(-7deg) translateY(calc(var(--szl-holo-scroll) * -2px));
+}
+
+/* Maritime: bathymetry, route wake, and radar. */
+html[data-szl-holo-motif="bathymetric-radar"] #szl-holo-ambient::before {
+  inset: 5% auto auto 52%;
+  width: min(78vw, 980px);
+  aspect-ratio: 1;
+  border: 1px solid var(--szl-holo-line);
+  border-radius: 50%;
+  background:
+    repeating-radial-gradient(circle, transparent 0 59px, var(--szl-holo-line) 60px 61px),
+    conic-gradient(from 12deg, color-mix(in srgb, var(--szl-holo-accent) 22%, transparent), transparent 16%);
+  animation: szl-holo-radar 18s linear infinite;
+}
+
+html[data-szl-holo-motif="bathymetric-radar"] #szl-holo-ambient::after {
+  background: repeating-radial-gradient(ellipse at 18% 82%, transparent 0 30px, var(--szl-holo-line) 31px 32px);
+  transform: rotate(-8deg) scale(1.28);
+  opacity: .34;
+}
+
+/* Real estate: topography and parcel geometry. */
+html[data-szl-holo-motif="topographic-parcels"] #szl-holo-ambient::before {
+  background:
+    repeating-radial-gradient(ellipse at 18% 58%, transparent 0 31px, var(--szl-holo-line) 32px 33px),
+    repeating-radial-gradient(ellipse at 84% 34%, transparent 0 49px, color-mix(in srgb, var(--szl-holo-accent-2) 18%, transparent) 50px 51px);
+  transform: rotate(-7deg) scale(1.18) translateY(calc(var(--szl-holo-scroll) * -1px));
+}
+
+html[data-szl-holo-motif="topographic-parcels"] #szl-holo-ambient::after {
+  background-image:
+    linear-gradient(28deg, transparent 48%, var(--szl-holo-line) 49% 50%, transparent 51%),
+    linear-gradient(118deg, transparent 48%, var(--szl-holo-line) 49% 50%, transparent 51%);
+  background-size: 180px 110px;
+  opacity: .26;
+}
+
+/* Security: threat lattice and shield lock. */
+html[data-szl-holo-motif="threat-lattice"] #szl-holo-ambient::before {
+  background:
+    linear-gradient(32deg, transparent 47%, var(--szl-holo-line) 48% 49%, transparent 50%),
+    linear-gradient(148deg, transparent 47%, color-mix(in srgb, var(--szl-holo-accent-2) 18%, transparent) 48% 49%, transparent 50%);
+  background-size: 84px 84px;
+  transform: skewX(-8deg) scale(1.12);
+  mask-image: radial-gradient(circle at 72% 28%, #000, transparent 62%);
+}
+
+html[data-szl-holo-motif="threat-lattice"] #szl-holo-ambient::after {
+  inset: 16% 6% auto auto;
+  width: clamp(150px, 22vw, 320px);
+  aspect-ratio: 1;
+  border: 1px solid var(--szl-holo-accent);
+  clip-path: polygon(50% 0, 93% 25%, 93% 75%, 50% 100%, 7% 75%, 7% 25%);
+  box-shadow: inset 0 0 70px var(--szl-holo-glow), 0 0 90px var(--szl-holo-glow);
+  opacity: .34;
+  animation: szl-holo-breathe 4.8s ease-in-out infinite alternate;
+}
+
+/* Legal: case facets and deadline lanes. */
+html[data-szl-holo-motif="case-facets"] #szl-holo-ambient::before {
+  background:
+    repeating-linear-gradient(0deg, transparent 0 51px, var(--szl-holo-line) 52px),
+    repeating-linear-gradient(90deg, transparent 0 219px, color-mix(in srgb, var(--szl-holo-accent-2) 17%, transparent) 220px 221px);
+  transform: rotate(-2deg);
+  mask-image: linear-gradient(90deg, transparent 2%, #000 20% 91%, transparent);
+}
+
+html[data-szl-holo-motif="case-facets"] #szl-holo-ambient::after {
+  background-image: radial-gradient(circle, var(--szl-holo-accent) 0 3px, transparent 4px);
+  background-size: 220px 52px;
+  opacity: .22;
+}
+
+/* Advisory: editorial orbits. */
+html[data-szl-holo-motif="editorial-orbit"] #szl-holo-ambient::before {
+  inset: -20% auto auto 44%;
+  width: min(82vw, 1040px);
+  aspect-ratio: 1;
+  border-radius: 50%;
+  background: repeating-radial-gradient(circle, transparent 0 74px, var(--szl-holo-line) 75px 76px);
+  transform: rotate(12deg) scaleY(.55);
+}
+
+html[data-szl-holo-motif="editorial-orbit"] #szl-holo-ambient::after {
+  background: linear-gradient(115deg, transparent 38%, var(--szl-holo-glow) 39% 41%, transparent 42% 62%, var(--szl-holo-glow-2) 63% 64%, transparent 65%);
+}
+
+/* Integration: connected node field. */
+html[data-szl-holo-motif="connection-field"] #szl-holo-ambient::before {
+  background:
+    radial-gradient(circle, var(--szl-holo-accent) 0 2px, transparent 3px),
+    linear-gradient(30deg, transparent 49%, var(--szl-holo-line) 50%, transparent 51%),
+    linear-gradient(150deg, transparent 49%, var(--szl-holo-line) 50%, transparent 51%);
+  background-size: 96px 96px;
+  mask-image: radial-gradient(circle at 55% 40%, #000, transparent 72%);
+  transform: translate3d(calc(var(--szl-holo-scroll) * .4px), calc(var(--szl-holo-scroll) * -.25px), 0);
+}
+
+/* Factory: build lanes and artifact promotion. */
+html[data-szl-holo-motif="assembly-circuit"] #szl-holo-ambient::before {
+  background:
+    radial-gradient(circle, var(--szl-holo-accent) 0 2px, transparent 3px),
+    linear-gradient(90deg, var(--szl-holo-line) 1px, transparent 1px),
+    linear-gradient(var(--szl-holo-line) 1px, transparent 1px);
+  background-size: 72px 72px;
+  clip-path: polygon(0 8%, 76% 8%, 76% 28%, 100% 28%, 100% 92%, 22% 92%, 22% 69%, 0 69%);
+  opacity: .42;
+}
+
+html[data-szl-holo-motif="assembly-circuit"] #szl-holo-ambient::after {
+  inset: 30% 12% auto auto;
+  width: clamp(180px, 22vw, 360px);
+  height: clamp(100px, 13vw, 210px);
+  border: 1px solid var(--szl-holo-line);
+  border-radius: var(--szl-holo-radius-lg);
+  box-shadow: inset 0 0 55px var(--szl-holo-glow), 0 0 55px var(--szl-holo-glow);
+}
+
+/* Research: recursive computational rings. */
+html[data-szl-holo-motif="recursive-ring"] #szl-holo-ambient::before {
+  inset: -24% -12%;
+  border-radius: 50%;
+  background: repeating-conic-gradient(from 0deg, var(--szl-holo-line) 0 1deg, transparent 1deg 13deg);
+  mask-image: repeating-radial-gradient(circle, #000 0 1px, transparent 2px 54px);
+  animation: szl-holo-recurse 42s linear infinite;
+}
+
+html[data-szl-holo-motif="recursive-ring"] #szl-holo-ambient::after {
+  inset: 18% auto auto 58%;
+  width: min(38vw, 460px);
+  aspect-ratio: 1;
+  border: 1px solid var(--szl-holo-accent);
+  border-radius: 50%;
+  box-shadow: inset 0 0 90px var(--szl-holo-glow), 0 0 90px var(--szl-holo-glow);
+  opacity: .38;
+}
+
+/* KHIPU: woven evidence traces. */
+html[data-szl-holo-motif="woven-proof"] #szl-holo-ambient::before {
+  background:
+    repeating-linear-gradient(28deg, transparent 0 25px, var(--szl-holo-line) 26px 27px),
+    repeating-linear-gradient(-28deg, transparent 0 31px, var(--szl-holo-glow-2) 32px 33px);
+  transform: scale(1.08);
+}
+
+html[data-szl-holo-motif="woven-proof"] #szl-holo-ambient::after {
+  background-image: radial-gradient(circle, var(--szl-holo-accent) 0 2px, transparent 3px);
+  background-size: 128px 96px;
+  opacity: .23;
+}
+
+/* Agents: governed swarm converging on a decision. */
+html[data-szl-holo-motif="agent-swarm"] #szl-holo-ambient::before {
+  background-image:
+    radial-gradient(circle at center, var(--szl-holo-accent) 0 2px, transparent 3px),
+    radial-gradient(circle at center, var(--szl-holo-accent-2) 0 1px, transparent 2px);
+  background-position: 0 0, 31px 27px;
+  background-size: 72px 68px, 89px 83px;
+  mask-image: radial-gradient(circle at 60% 42%, #000, transparent 68%);
+  animation: szl-holo-swarm 24s ease-in-out infinite alternate;
+}
+
+html[data-szl-holo-motif="agent-swarm"] #szl-holo-ambient::after {
+  background:
+    linear-gradient(25deg, transparent 49.6%, var(--szl-holo-line) 50%, transparent 50.4%),
+    linear-gradient(155deg, transparent 49.6%, var(--szl-holo-line) 50%, transparent 50.4%);
+  background-size: 140px 90px;
+  opacity: .2;
+}
+
+/* Proof: restrained evidence-vault geometry. */
+html[data-szl-holo-motif="evidence-vault"] #szl-holo-ambient::before {
+  background:
+    repeating-linear-gradient(0deg, transparent 0 35px, var(--szl-holo-line-soft) 36px),
+    linear-gradient(90deg, transparent 0 13%, var(--szl-holo-line) 13.1%, transparent 13.3% 76%, var(--szl-holo-line) 76.1%, transparent 76.3%);
+  mask-image: linear-gradient(90deg, transparent, #000 14% 86%, transparent);
+}
+
+html[data-szl-holo-motif="evidence-vault"] #szl-holo-ambient::after {
+  background-image: radial-gradient(circle, var(--szl-holo-accent) 0 2px, transparent 3px);
+  background-size: 144px 72px;
+  opacity: .18;
+}
+
+/* Shared top rail. */
+.szl-holo-rail {
+  position: sticky;
+  top: 0;
+  z-index: var(--szl-holo-z-rail);
+  min-height: var(--szl-holo-rail-height);
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--szl-holo-space-2);
+  padding: 8px max(12px, env(safe-area-inset-left)) 8px max(12px, env(safe-area-inset-right));
+  border-bottom: 1px solid var(--szl-holo-line);
+  color: var(--szl-holo-ink);
+  background: color-mix(in srgb, var(--szl-holo-bg) 86%, transparent);
+  box-shadow: 0 14px 44px rgb(0 0 0 / .24);
+  backdrop-filter: blur(20px) saturate(135%);
+  -webkit-backdrop-filter: blur(20px) saturate(135%);
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+.szl-holo-rail *,
+.szl-holo-rail *::before,
+.szl-holo-rail *::after { box-sizing: border-box; }
+
+.szl-holo-identity {
+  min-width: 0;
+  min-height: 44px;
+  display: inline-flex;
+  align-items: center;
+  gap: 11px;
+  color: inherit;
+  text-decoration: none;
+}
+
+.szl-holo-mark {
+  position: relative;
+  width: 28px;
+  height: 28px;
+  flex: 0 0 auto;
+  border: 1px solid color-mix(in srgb, var(--szl-holo-accent) 62%, white 10%);
+  border-radius: 9px;
+  background:
+    radial-gradient(circle at 26% 24%, var(--szl-holo-accent), transparent 34%),
+    linear-gradient(145deg, color-mix(in srgb, var(--szl-holo-accent-2) 72%, transparent), transparent 72%);
+  box-shadow: 0 0 28px var(--szl-holo-glow);
+  transform: rotate(8deg);
+}
+
+.szl-holo-mark::after {
+  position: absolute;
+  inset: 5px;
+  border: 1px solid color-mix(in srgb, var(--szl-holo-ink) 36%, transparent);
+  border-radius: 5px;
+  content: "";
+  transform: rotate(-18deg);
+}
+
+.szl-holo-copy {
+  min-width: 0;
+  display: grid;
+  gap: 1px;
+}
+
+.szl-holo-eyebrow {
+  overflow: hidden;
+  color: var(--szl-holo-muted);
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: .19em;
+  text-overflow: ellipsis;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
+.szl-holo-label {
+  overflow: hidden;
+  font-size: 13px;
+  font-weight: 760;
+  letter-spacing: -.01em;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.szl-holo-nav {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.szl-holo-link,
+.szl-holo-menu {
+  min-width: 44px;
+  min-height: 44px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 8px 11px;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  color: var(--szl-holo-muted);
+  background: transparent;
+  font: 660 11px/1.2 Inter, ui-sans-serif, system-ui, sans-serif;
+  letter-spacing: .045em;
+  text-decoration: none;
+  cursor: pointer;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.szl-holo-link:hover,
+.szl-holo-link:focus-visible,
+.szl-holo-link[aria-current="page"],
+.szl-holo-menu:hover,
+.szl-holo-menu:focus-visible {
+  border-color: color-mix(in srgb, var(--szl-holo-accent) 38%, transparent);
+  color: var(--szl-holo-ink);
+  background: color-mix(in srgb, var(--szl-holo-accent) 9%, transparent);
+  outline: none;
+}
+
+.szl-holo-menu { display: none; }
+
+/* Reusable opt-in materials. */
+.szl-holo-panel,
+[data-szl-holo-panel] {
+  position: relative;
+  overflow: hidden;
+  border: 1px solid var(--szl-holo-line-soft);
+  border-radius: var(--szl-holo-radius-md);
+  background:
+    linear-gradient(145deg, color-mix(in srgb, var(--szl-holo-surface-2) 60%, transparent), transparent 44%),
+    color-mix(in srgb, var(--szl-holo-surface) 86%, transparent);
+  box-shadow: var(--szl-holo-shadow);
+  backdrop-filter: blur(18px) saturate(125%);
+  -webkit-backdrop-filter: blur(18px) saturate(125%);
+  transform-style: preserve-3d;
+}
+
+.szl-holo-panel::before,
+[data-szl-holo-panel]::before {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  content: "";
+  background: radial-gradient(circle at var(--szl-holo-pointer-x) var(--szl-holo-pointer-y), color-mix(in srgb, var(--szl-holo-accent) 13%, transparent), transparent 22rem);
+  opacity: .65;
+}
+
+.szl-holo-panel::after,
+[data-szl-holo-panel]::after {
+  position: absolute;
+  inset: -1px;
+  pointer-events: none;
+  content: "";
+  border-radius: inherit;
+  background: linear-gradient(118deg, transparent 12%, color-mix(in srgb, var(--szl-holo-ink) 9%, transparent) 38%, transparent 62%);
+  transform: translateX(-110%);
+  animation: szl-holo-specular 11s ease-in-out infinite;
+}
+
+.szl-holo-kicker,
+[data-szl-holo-kicker] {
+  color: var(--szl-holo-accent);
+  font-size: .72rem;
+  font-weight: 780;
+  letter-spacing: .18em;
+  text-transform: uppercase;
+}
+
+.szl-holo-title,
+[data-szl-holo-title] {
+  color: var(--szl-holo-ink);
+  background: linear-gradient(112deg, var(--szl-holo-ink), var(--szl-holo-accent) 58%, var(--szl-holo-accent-2));
+  background-clip: text;
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  text-wrap: balance;
+}
+
+.szl-holo-muted { color: var(--szl-holo-muted); }
+.szl-holo-rule { border-color: var(--szl-holo-line); }
+
+.szl-holo-chip {
+  min-height: 32px;
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  padding: 5px 10px;
+  border: 1px solid var(--szl-holo-line-soft);
+  border-radius: 999px;
+  color: var(--szl-holo-muted);
+  background: color-mix(in srgb, var(--szl-holo-surface) 78%, transparent);
+  font: 650 11px/1.2 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+
+.szl-holo-chip::before {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--szl-holo-accent);
+  box-shadow: 0 0 14px var(--szl-holo-accent);
+  content: "";
+}
+
+.szl-holo-evidence-ribbon {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--szl-holo-space-2);
+  padding: 10px 12px;
+  border-block: 1px solid var(--szl-holo-line-soft);
+  color: var(--szl-holo-muted);
+  font: 600 11px/1.4 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+
+.szl-holo-evidence-ribbon strong { color: var(--szl-holo-ink); }
+
+.szl-holo-progress {
+  position: fixed;
+  inset: 0 auto auto 0;
+  z-index: calc(var(--szl-holo-z-rail) + 1);
+  width: calc(var(--szl-holo-scroll) * 1%);
+  height: 2px;
+  pointer-events: none;
+  background: linear-gradient(90deg, var(--szl-holo-accent), var(--szl-holo-accent-2));
+  box-shadow: 0 0 18px var(--szl-holo-glow);
+}
+
+.szl-holo-skip {
+  position: fixed;
+  top: 8px;
+  left: 8px;
+  z-index: calc(var(--szl-holo-z-rail) + 3);
+  padding: 11px 14px;
+  border: 2px solid var(--szl-holo-accent);
+  border-radius: var(--szl-holo-radius-sm);
+  color: var(--szl-holo-bg);
+  background: var(--szl-holo-accent);
+  font: 760 14px/1.2 ui-sans-serif, system-ui, sans-serif;
+  text-decoration: none;
+  transform: translateY(-160%);
+  transition: transform .16s ease;
+}
+
+.szl-holo-skip:focus { transform: translateY(0); }
+
+html[data-szl-holo="v2"] :where(a, button, input, textarea, select, summary, [tabindex]):focus-visible {
+  outline: 2px solid var(--szl-holo-accent) !important;
+  outline-offset: 3px !important;
+}
+
+@keyframes szl-holo-orbit {
+  to { transform: rotate(351deg) scaleY(.58); }
+}
+
+@keyframes szl-holo-aurora {
+  from { transform: translate3d(-5%, -3%, 0) rotate(-8deg) scale(1); }
+  to { transform: translate3d(7%, 6%, 0) rotate(11deg) scale(1.08); }
+}
+
+@keyframes szl-holo-radar {
+  to { transform: rotate(360deg); }
+}
+
+@keyframes szl-holo-recurse {
+  to { transform: rotate(-360deg); }
+}
+
+@keyframes szl-holo-swarm {
+  from { transform: translate3d(-1.5%, -1%, 0) scale(1); }
+  to { transform: translate3d(1.5%, 1%, 0) scale(1.04); }
+}
+
+@keyframes szl-holo-breathe {
+  from { opacity: .22; transform: scale(.96); }
+  to { opacity: .42; transform: scale(1.03); }
+}
+
+@keyframes szl-holo-specular {
+  0%, 68%, 100% { transform: translateX(-115%); }
+  82% { transform: translateX(115%); }
+}
+
+@media (max-width: 760px) {
+  :root { --szl-holo-rail-height: 56px; }
+  #szl-holo-ambient { opacity: .62; }
+  .szl-holo-menu { display: inline-flex; }
+  .szl-holo-nav {
+    position: absolute;
+    top: calc(100% + 7px);
+    right: max(8px, env(safe-area-inset-right));
+    min-width: min(240px, calc(100vw - 16px));
+    display: none;
+    flex-direction: column;
+    align-items: stretch;
+    gap: 3px;
+    padding: 8px;
+    border: 1px solid var(--szl-holo-line);
+    border-radius: var(--szl-holo-radius-md);
+    background: color-mix(in srgb, var(--szl-holo-bg) 96%, white 2%);
+    box-shadow: var(--szl-holo-shadow);
+  }
+  .szl-holo-nav[data-open="true"] { display: flex; }
+  .szl-holo-link { justify-content: flex-start; padding-inline: 14px; }
+  .szl-holo-eyebrow { display: none; }
+  .szl-holo-panel::after,
+  [data-szl-holo-panel]::after { display: none; }
+}
+
+@media (max-width: 390px) {
+  .szl-holo-label { max-width: 48vw; }
+  .szl-holo-mark { width: 25px; height: 25px; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  html[data-szl-holo="v2"] { scroll-behavior: auto; }
+  #szl-holo-ambient::before,
+  #szl-holo-ambient::after,
+  .szl-holo-panel::after,
+  [data-szl-holo-panel]::after,
+  .szl-holo-skip,
+  .szl-holo-mark {
+    animation: none !important;
+    transition: none !important;
+    transform: none !important;
+  }
+  .szl-holo-progress { box-shadow: none; }
+}
+
+@media (prefers-contrast: more) {
+  :root {
+    --szl-holo-line: color-mix(in srgb, var(--szl-holo-accent) 58%, transparent);
+    --szl-holo-line-soft: color-mix(in srgb, var(--szl-holo-ink) 34%, transparent);
+  }
+  #szl-holo-ambient { opacity: .32; }
+  .szl-holo-panel,
+  [data-szl-holo-panel] {
+    border-width: 2px;
+    background: var(--szl-holo-surface);
+    backdrop-filter: none;
+  }
+}
+
+@media (forced-colors: active) {
+  :root { color-scheme: light dark; }
+  #szl-holo-ambient,
+  .szl-holo-progress { display: none; }
+  .szl-holo-rail,
+  .szl-holo-panel,
+  [data-szl-holo-panel],
+  .szl-holo-link,
+  .szl-holo-menu,
+  .szl-holo-chip {
+    border: 1px solid CanvasText;
+    color: CanvasText;
+    background: Canvas;
+    box-shadow: none;
+    backdrop-filter: none;
+  }
+  .szl-holo-title,
+  [data-szl-holo-title] {
+    color: CanvasText;
+    background: none;
+    -webkit-text-fill-color: currentColor;
+  }
+  .szl-holo-mark { border-color: CanvasText; background: CanvasText; box-shadow: none; }
+  .szl-holo-skip { color: Canvas; background: CanvasText; border-color: CanvasText; }
+}
+
+@supports not (color: color-mix(in srgb, black 50%, white)) {
+  .szl-holo-rail,
+  .szl-holo-panel,
+  [data-szl-holo-panel] { background: var(--szl-holo-surface); }
+  .szl-holo-link[aria-current="page"] { border-color: var(--szl-holo-accent); }
+}
+
+@media print {
+  #szl-holo-ambient,
+  .szl-holo-rail,
+  .szl-holo-progress,
+  .szl-holo-skip { display: none !important; }
+  html[data-szl-holo="v2"],
+  html[data-szl-holo="v2"] body {
+    color: #000 !important;
+    background: #fff !important;
+  }
+  .szl-holo-panel,
+  [data-szl-holo-panel] {
+    border: 1px solid #444;
+    color: #000;
+    background: #fff;
+    box-shadow: none;
+  }
+}

szl-holo-v2.js

@@ -0,0 +1,437 @@
+/*
+ * A11oy Holo-Constellation v2.0.0
+ * Deterministic route identity, accessible estate navigation, and low-cost
+ * progressive visual enhancement. No fetch, tracking, storage, or cookies.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+(() => {
+  "use strict";
+
+  if (window.__SZL_HOLO_V2__) return;
+  window.__SZL_HOLO_V2__ = true;
+
+  const VERSION = "2.0.0";
+  const PRODUCT = "https://a-11-oy.com";
+  const PROOF = "https://a11oy.net";
+  const REDUCE_MOTION = window.matchMedia("(prefers-reduced-motion: reduce)");
+  const FINE_POINTER = window.matchMedia("(pointer: fine)");
+  const SAVE_DATA = Boolean(navigator.connection && navigator.connection.saveData);
+
+  const PALETTES = [
+    ["#07131a", "#102633", "#f2fbff", "#9ab4c2", "#64dcff", "#a88bff"],
+    ["#130a10", "#291522", "#fff6fb", "#c2a2b3", "#ff7bc3", "#ffb56b"],
+    ["#07140d", "#12281a", "#f5fff7", "#9db8a4", "#72efa0", "#5ad6ff"],
+    ["#130e06", "#2a1d0e", "#fffaf0", "#c2b297", "#ffc66d", "#ff7d73"],
+    ["#090a18", "#171932", "#f6f6ff", "#a6a8c4", "#878cff", "#54e4d7"],
+    ["#0f0715", "#24102f", "#fff6ff", "#bca6c5", "#d88cff", "#74c6ff"],
+    ["#061315", "#10272b", "#f1feff", "#9bb9bb", "#50e3d4", "#b4ed70"],
+    ["#140808", "#2d1414", "#fff6f4", "#c2a3a0", "#ff6c63", "#e9cf6f"],
+    ["#0a1115", "#16242c", "#f5fbff", "#a3b2bb", "#83c7ff", "#8df0bd"],
+    ["#111006", "#282512", "#fffef0", "#beb99b", "#e5f36b", "#e8a85f"],
+    ["#0b0714", "#1c122c", "#faf6ff", "#aea2c0", "#b697ff", "#ff82ad"],
+    ["#07120f", "#12251f", "#f2fff9", "#9db6aa", "#75e8b4", "#c1a0ff"],
+  ];
+
+  const CURATED = {
+    a11oy: {
+      label: "A11oy Command",
+      motif: "command-constellation",
+      palette: ["#050806", "#0c1513", "#f3fff8", "#9fb7ad", "#b8ff45", "#31e6d1"],
+    },
+    proof: {
+      label: "A11oy Proof Network",
+      motif: "evidence-vault",
+      palette: ["#060a10", "#101722", "#f1f5f8", "#9eabb6", "#76d8aa", "#e2bb6d"],
+    },
+    lyte: {
+      label: "Lyte",
+      motif: "signal-aurora",
+      palette: ["#03100f", "#0a211d", "#effffb", "#92bdb2", "#50ffd0", "#78a8ff"],
+    },
+    vessels: {
+      label: "Vessels",
+      motif: "bathymetric-radar",
+      palette: ["#020d18", "#09243a", "#effbff", "#8cb5c9", "#50ddff", "#2d7cff"],
+    },
+    terra: {
+      label: "Terra",
+      motif: "topographic-parcels",
+      palette: ["#06110b", "#12271a", "#f5fff7", "#9db7a3", "#7bea98", "#d9a45c"],
+    },
+    aegis: {
+      label: "Aegis",
+      motif: "threat-lattice",
+      palette: ["#120606", "#281010", "#fff4f2", "#c6a19c", "#ff625b", "#ffb34d"],
+    },
+    "prism-counsel": {
+      label: "PRISM Counsel",
+      motif: "case-facets",
+      palette: ["#070b18", "#141a31", "#f8f9ff", "#a8b0ca", "#7da8ff", "#d7c4ff"],
+    },
+    "carlota-jo": {
+      label: "Carlota Jo",
+      motif: "editorial-orbit",
+      palette: ["#140a17", "#2b1330", "#fff7ff", "#c6a8c7", "#e2a8ff", "#ef9b67"],
+    },
+    nexus: {
+      label: "Nexus",
+      motif: "connection-field",
+      palette: ["#070918", "#151831", "#f7f7ff", "#a5aac8", "#9a8cff", "#53e9ff"],
+    },
+    factory: {
+      label: "A11oy Factory",
+      motif: "assembly-circuit",
+      palette: ["#070c07", "#171f13", "#fafff5", "#abb9a4", "#c9ff5c", "#7e9cff"],
+    },
+    ouroboros: {
+      label: "Ouroboros",
+      motif: "recursive-ring",
+      palette: ["#100b05", "#24180b", "#fffaf0", "#c4b59b", "#ffd36e", "#c094ff"],
+    },
+    khipu: {
+      label: "KHIPU",
+      motif: "woven-proof",
+      palette: ["#120b05", "#271a0e", "#fff9ee", "#c6b39b", "#e9c66e", "#c87945"],
+    },
+    killinchu: {
+      label: "Killinchu",
+      motif: "agent-swarm",
+      palette: ["#100615", "#26102e", "#fff5ff", "#c5a4c9", "#ff74d4", "#68e8ff"],
+    },
+  };
+
+  const ROUTE_HINTS = [
+    ["prism-counsel", ["prism-counsel", "prism counsel", "/counsel", "/legal"]],
+    ["carlota-jo", ["carlota-jo", "carlota jo", "/advisory"]],
+    ["ouroboros", ["ouroboros", "/research", "/thesis"]],
+    ["killinchu", ["killinchu", "/agents", "agent forge", "agent swarm"]],
+    ["factory", ["a11oy-factory", "szl-factory", "/factory", "/forge", "artifact factory"]],
+    ["vessels", ["vessels", "/maritime", "fleet command", "voyage"]],
+    ["terra", ["terra", "/real-estate", "real estate", "parcel"]],
+    ["aegis", ["aegis", "/security", "/defense", "threat"]],
+    ["lyte", ["lyte", "/observability", "business observability", "signal"]],
+    ["nexus", ["nexus", "/integration", "connection fabric"]],
+    ["khipu", ["khipu", "/kernel", "woven proof"]],
+  ];
+
+  const MOTIFS = [
+    "command-constellation",
+    "signal-aurora",
+    "bathymetric-radar",
+    "topographic-parcels",
+    "threat-lattice",
+    "case-facets",
+    "editorial-orbit",
+    "connection-field",
+    "assembly-circuit",
+    "recursive-ring",
+    "woven-proof",
+    "agent-swarm",
+  ];
+
+  const LINKS = [
+    ["Command", `${PRODUCT}/`],
+    ["Products", `${PRODUCT}/console`],
+    ["Proof", `${PROOF}/record/`],
+    ["Source", "https://github.com/szl-holdings"],
+    ["Spaces", "https://huggingface.co/SZLHOLDINGS"],
+  ];
+
+  function slug(value) {
+    return String(value || "")
+      .normalize("NFKD")
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 96);
+  }
+
+  function fnv1a(value) {
+    let result = 0x811c9dc5;
+    for (const character of String(value || "a11oy")) {
+      result ^= character.charCodeAt(0);
+      result = Math.imul(result, 0x01000193) >>> 0;
+    }
+    return result >>> 0;
+  }
+
+  function titleCase(value) {
+    return String(value || "")
+      .split("-")
+      .filter(Boolean)
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+      .join(" ");
+  }
+
+  function huggingFaceSlug(host) {
+    const match = host.match(/^(?:szlholdings|szl-holdings)-(.+)\.hf\.space$/i);
+    return match ? slug(match[1]) : "";
+  }
+
+  function surfaceCandidate() {
+    const host = location.hostname.toLowerCase();
+    if (host === "a11oy.net" || host === "www.a11oy.net") return "proof";
+    if (host === "a-11-oy.com" || host === "www.a-11-oy.com") {
+      const path = location.pathname.toLowerCase();
+      for (const [surface, hints] of ROUTE_HINTS) {
+        if (hints.some((hint) => path.includes(hint.replace(" ", "-")))) return surface;
+      }
+      return "a11oy";
+    }
+
+    const hf = huggingFaceSlug(host);
+    const path = location.pathname.toLowerCase();
+    const title = document.title.toLowerCase();
+    const bodyIdentity = `${document.body?.id || ""} ${document.body?.className || ""}`.toLowerCase();
+    const haystack = `${host} ${hf} ${path} ${title} ${bodyIdentity}`;
+
+    for (const [surface, hints] of ROUTE_HINTS) {
+      if (hints.some((hint) => haystack.includes(hint))) return surface;
+    }
+    if (hf) return hf;
+    return slug(path.split("/").filter(Boolean)[0]) || slug(host) || "a11oy";
+  }
+
+  function resolveTheme() {
+    return {"id":"anatomy","label":"Anatomy","motif":"signal-aurora","palette":["#061315","#10272b","#f1feff","#9bb9bb","#50e3d4","#b4ed70"],"source":"space-specific"};
+    const id = surfaceCandidate();
+    const curated = CURATED[id];
+    if (curated) return { id, ...curated, source: "curated" };
+
+    const seed = fnv1a(id);
+    const palette = PALETTES[seed % PALETTES.length];
+    return {
+      id,
+      label: titleCase(id) || "A11oy Space",
+      motif: MOTIFS[(seed >>> 8) % MOTIFS.length],
+      palette,
+      source: "deterministic",
+    };
+  }
+
+  function applyTheme(theme) {
+    const [background, surface, foreground, muted, accent, accent2] = theme.palette;
+    const root = document.documentElement;
+    root.dataset.szlHolo = "v2";
+    root.dataset.szlHoloSurface = theme.id;
+    root.dataset.szlHoloMotif = theme.motif;
+    root.dataset.szlHoloThemeSource = theme.source;
+    root.style.setProperty("--szl-holo-bg", background);
+    root.style.setProperty("--szl-holo-bg-deep", background);
+    root.style.setProperty("--szl-holo-surface", surface);
+    root.style.setProperty("--szl-holo-surface-2", surface);
+    root.style.setProperty("--szl-holo-ink", foreground);
+    root.style.setProperty("--szl-holo-muted", muted);
+    root.style.setProperty("--szl-holo-accent", accent);
+    root.style.setProperty("--szl-holo-accent-2", accent2);
+  }
+
+  function createElement(name, attributes = {}, text = null) {
+    const node = document.createElement(name);
+    for (const [key, value] of Object.entries(attributes)) {
+      if (key === "className") node.className = value;
+      else if (key === "dataset") Object.assign(node.dataset, value);
+      else node.setAttribute(key, value);
+    }
+    if (text !== null) node.textContent = text;
+    return node;
+  }
+
+  function addSkipLink() {
+    if (document.querySelector(".szl-holo-skip, [data-szl-holo-skip]")) return;
+    const main = document.querySelector("main, [role='main']");
+    if (!main) return;
+    if (!main.id) main.id = "szl-holo-main";
+    const link = createElement("a", {
+      className: "szl-holo-skip",
+      href: `#${main.id}`,
+      dataset: { szlHoloSkip: "true" },
+    }, "Skip to main content");
+    document.body.prepend(link);
+  }
+
+  function currentLink(href) {
+    const target = new URL(href);
+    const host = location.hostname.replace(/^www\./, "");
+    if (target.hostname.replace(/^www\./, "") !== host) return false;
+    if (target.pathname === "/") return location.pathname === "/";
+    return location.pathname.startsWith(target.pathname.replace(/\/$/, ""));
+  }
+
+  function buildRail(theme) {
+    if (document.querySelector(".szl-holo-rail") || document.documentElement.hasAttribute("data-szl-holo-no-rail")) return;
+
+    const rail = createElement("header", {
+      className: "szl-holo-rail",
+      dataset: { szlHoloRail: "v2" },
+    });
+    const identity = createElement("a", {
+      className: "szl-holo-identity",
+      href: `${PRODUCT}/`,
+      "aria-label": "Open the A11oy Command origin",
+    });
+    identity.append(createElement("span", { className: "szl-holo-mark", "aria-hidden": "true" }));
+    const copy = createElement("span", { className: "szl-holo-copy" });
+    copy.append(createElement("span", { className: "szl-holo-eyebrow" }, "SZL · Holo-Constellation"));
+    copy.append(createElement("span", { className: "szl-holo-label" }, theme.label));
+    identity.append(copy);
+
+    const controls = createElement("div", { className: "szl-holo-controls" });
+    const menu = createElement("button", {
+      className: "szl-holo-menu",
+      type: "button",
+      "aria-label": "Open ecosystem navigation",
+      "aria-expanded": "false",
+      "aria-controls": "szl-holo-nav",
+    }, "Menu");
+    const nav = createElement("nav", {
+      className: "szl-holo-nav",
+      id: "szl-holo-nav",
+      "aria-label": "A11oy ecosystem",
+      dataset: { open: "false" },
+    });
+    for (const [label, href] of LINKS) {
+      const attributes = { className: "szl-holo-link", href };
+      if (currentLink(href)) attributes["aria-current"] = "page";
+      nav.append(createElement("a", attributes, label));
+    }
+    controls.append(menu, nav);
+    rail.append(identity, controls);
+    document.body.prepend(rail);
+
+    const close = ({ focus = false } = {}) => {
+      nav.dataset.open = "false";
+      menu.setAttribute("aria-expanded", "false");
+      menu.setAttribute("aria-label", "Open ecosystem navigation");
+      menu.textContent = "Menu";
+      if (focus) menu.focus();
+    };
+
+    menu.addEventListener("click", () => {
+      const open = nav.dataset.open !== "true";
+      nav.dataset.open = String(open);
+      menu.setAttribute("aria-expanded", String(open));
+      menu.setAttribute("aria-label", open ? "Close ecosystem navigation" : "Open ecosystem navigation");
+      menu.textContent = open ? "Close" : "Menu";
+    });
+    document.addEventListener("keydown", (event) => {
+      if (event.key === "Escape" && nav.dataset.open === "true") close({ focus: true });
+    });
+    document.addEventListener("pointerdown", (event) => {
+      if (nav.dataset.open === "true" && !rail.contains(event.target)) close();
+    });
+  }
+
+  function addAmbient() {
+    if (document.getElementById("szl-holo-ambient")) return;
+    const ambient = createElement("div", {
+      id: "szl-holo-ambient",
+      "aria-hidden": "true",
+      dataset: { szlHoloDecorative: "true" },
+    });
+    document.body.prepend(ambient);
+  }
+
+  function addProgress() {
+    if (document.querySelector(".szl-holo-progress")) return;
+    document.body.append(createElement("div", {
+      className: "szl-holo-progress",
+      "aria-hidden": "true",
+      dataset: { szlHoloDecorative: "true" },
+    }));
+  }
+
+  function enhancePanels() {
+    if (document.documentElement.hasAttribute("data-szl-holo-no-auto-panels")) return;
+    const selectors = [
+      "main .card",
+      "main .panel",
+      "main .metric-card",
+      "main .feature-card",
+      "main [class*='glass-card']",
+      "main [class*='holo-card']",
+      "main [data-panel]",
+    ];
+    const seen = new Set();
+    for (const node of document.querySelectorAll(selectors.join(","))) {
+      if (seen.size >= 24) break;
+      if (seen.has(node) || node.closest("nav, header, footer, table, pre, code, form, dialog")) continue;
+      seen.add(node);
+      node.setAttribute("data-szl-holo-panel", "auto");
+    }
+  }
+
+  function installMotion() {
+    const root = document.documentElement;
+    let pointerFrame = 0;
+    let scrollFrame = 0;
+    let lastX = window.innerWidth / 2;
+    let lastY = Math.min(window.innerHeight * 0.22, 240);
+
+    const commitPointer = () => {
+      pointerFrame = 0;
+      root.style.setProperty("--szl-holo-pointer-x", `${Math.round((lastX / Math.max(window.innerWidth, 1)) * 1000) / 10}%`);
+      root.style.setProperty("--szl-holo-pointer-y", `${Math.round((lastY / Math.max(window.innerHeight, 1)) * 1000) / 10}%`);
+    };
+
+    const pointer = (event) => {
+      if (REDUCE_MOTION.matches || !FINE_POINTER.matches || SAVE_DATA || document.hidden) return;
+      lastX = event.clientX;
+      lastY = event.clientY;
+      if (!pointerFrame) pointerFrame = requestAnimationFrame(commitPointer);
+    };
+
+    const commitScroll = () => {
+      scrollFrame = 0;
+      const maximum = Math.max(1, document.documentElement.scrollHeight - window.innerHeight);
+      const percentage = Math.max(0, Math.min(100, (window.scrollY / maximum) * 100));
+      root.style.setProperty("--szl-holo-scroll", percentage.toFixed(2));
+    };
+
+    const scroll = () => {
+      if (!scrollFrame) scrollFrame = requestAnimationFrame(commitScroll);
+    };
+
+    if (!SAVE_DATA) window.addEventListener("pointermove", pointer, { passive: true });
+    window.addEventListener("scroll", scroll, { passive: true });
+    window.addEventListener("resize", scroll, { passive: true });
+    document.addEventListener("visibilitychange", () => {
+      root.dataset.szlHoloPaused = String(document.hidden);
+      if (!document.hidden) scroll();
+    });
+    REDUCE_MOTION.addEventListener?.("change", () => {
+      root.dataset.szlHoloReducedMotion = String(REDUCE_MOTION.matches);
+    });
+    root.dataset.szlHoloReducedMotion = String(REDUCE_MOTION.matches);
+    root.dataset.szlHoloSaveData = String(SAVE_DATA);
+    commitPointer();
+    commitScroll();
+  }
+
+  function boot() {
+    if (!document.body || document.documentElement.hasAttribute("data-szl-holo-disabled")) return;
+    const theme = resolveTheme();
+    applyTheme(theme);
+    addAmbient();
+    addProgress();
+    addSkipLink();
+    buildRail(theme);
+    enhancePanels();
+    installMotion();
+
+    window.SZLHolo = Object.freeze({
+      version: VERSION,
+      theme: Object.freeze({ ...theme, palette: [...theme.palette] }),
+      resolveTheme,
+      fnv1a,
+      decorativeMotion: true,
+      measuredTelemetry: false,
+    });
+    document.dispatchEvent(new CustomEvent("szl:holo-ready", {
+      detail: { version: VERSION, surface: theme.id, motif: theme.motif, source: theme.source },
+    }));
+  }
+
+  if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", boot, { once: true });
+  else boot();
+})();

tests/qa_evidence_bay.js

@@ -0,0 +1,105 @@
+// End-to-end UI contract for the Anatomy Evidence Bay.
+// Requires the real Python server to be running; does not mock evidence APIs.
+const { chromium } = require('playwright');
+const path = require('path');
+
+const BASE = process.env.ANATOMY_BASE_URL || 'http://127.0.0.1:7860';
+const EDGE = process.env.PLAYWRIGHT_EXECUTABLE_PATH || undefined;
+const OUT = process.env.ANATOMY_QA_OUTPUT || __dirname;
+const VIEWPORTS = [
+  { name:'desktop', width:1440, height:900 },
+  { name:'mobile', width:390, height:844 },
+];
+
+async function run(browser, vp) {
+  const page = await browser.newPage({viewport:{width:vp.width,height:vp.height}});
+  const errors = [];
+  page.on('console', msg => { if (msg.type()==='error') errors.push(msg.text()); });
+  page.on('pageerror', err => errors.push('PAGEERROR: '+err.message));
+  const initialEvidence = page.waitForResponse(response => {
+    const url = new URL(response.url());
+    return url.pathname === '/api/anatomy/v1/evidence' && response.request().method() === 'GET';
+  }, {timeout:45000});
+  await page.goto(BASE+'/', {waitUntil:'networkidle'});
+  await page.waitForSelector('#fa-launch');
+  await page.click('#fa-launch');
+  await page.waitForSelector('#fa-panel.open');
+  const initialEvidenceResponse = await initialEvidence;
+  if (initialEvidenceResponse.status() !== 200) throw new Error(vp.name+' initial evidence HTTP '+initialEvidenceResponse.status());
+
+  const overview = await page.evaluate(() => ({
+    title: document.querySelector('.fa-title')?.textContent,
+    dimensions: [...document.querySelectorAll('.fa-dim-value')].map(x=>x.textContent),
+    launcher: getComputedStyle(document.getElementById('fa-launch')).display,
+    panelWidth: document.getElementById('fa-panel').getBoundingClientRect().width,
+    viewport: window.innerWidth,
+  }));
+
+  await page.click('[data-tab="capabilities"]');
+  const capabilityCount = await page.locator('.fa-cap').count();
+  // textContent covers the complete declarative shell even when the browser
+  // collapses detail descendants during layout/animation.
+  const shellText = await page.locator('.fa-cap').first().textContent();
+
+  await page.click('[data-tab="evidence"]');
+  try {
+    await page.waitForSelector('.fa-dep');
+  } catch (error) {
+    const activeTab = await page.locator('.fa-tab.active').innerText({timeout:2000}).catch(()=>'missing');
+    const evidenceBody = await page.locator('#fa-body').innerText({timeout:2000}).catch(()=>'missing');
+    throw new Error(vp.name+' evidence panel timeout; active='+activeTab+'; body='+evidenceBody+'; console='+errors.join(' | ')+'; '+error.message);
+  }
+  const dependencyCount = await page.locator('.fa-dep').count();
+  const dependencyStates = await page.locator('.fa-dep-state').allInnerTexts();
+
+  await page.click('[data-tab="reproduce"]');
+  const endpointTexts = await page.locator('.fa-endpoint a').allInnerTexts();
+  const [versionResponse, evidenceResponse] = await Promise.all([
+    page.request.get(BASE+'/version'),
+    page.request.get(BASE+'/evidence'),
+  ]);
+  const contracts = {
+    versionStatus: versionResponse.status(),
+    evidenceStatus: evidenceResponse.status(),
+    version: await versionResponse.json(),
+    evidence: await evidenceResponse.json(),
+  };
+
+  await page.click('[data-tab="overview"]');
+  await page.click('#fa-verify-bundle');
+  await page.waitForSelector('.fa-output.good');
+  const verification = await page.locator('.fa-output').innerText();
+
+  await page.screenshot({path:path.join(OUT,'anatomy-evidence-'+vp.name+'.png'),fullPage:true});
+  await page.close();
+
+  if (errors.length) throw new Error(vp.name+' console errors: '+errors.join(' | '));
+  if (overview.title !== 'Evidence Bay') throw new Error(vp.name+' missing Evidence Bay title');
+  if (overview.panelWidth > overview.viewport + 1) throw new Error(vp.name+' panel overflows viewport');
+  if (capabilityCount < 5) throw new Error(vp.name+' capability count '+capabilityCount);
+  for (const field of ['Purpose','Try','Evidence','Limits','Reproduce']) {
+    if (!shellText.includes(field)) throw new Error(vp.name+' missing '+field+' shell');
+  }
+  if (dependencyCount !== 4) throw new Error(vp.name+' dependency count '+dependencyCount);
+  if (!endpointTexts.some(text => text.includes('/version'))) throw new Error(vp.name+' missing /version discovery');
+  if (!endpointTexts.some(text => text.includes('/evidence'))) throw new Error(vp.name+' missing /evidence discovery');
+  if (contracts.version.schemaVersion !== 'szl.vertical-conformance.version.v1') throw new Error(vp.name+' version schema failed');
+  if (contracts.evidence.schemaVersion !== 'szl.vertical-conformance.evidence.v1') throw new Error(vp.name+' evidence schema failed');
+  if (contracts.version.evidenceState === 'MEASURED' ? contracts.versionStatus !== 200 : contracts.versionStatus !== 503) throw new Error(vp.name+' version transport/state mismatch');
+  if (contracts.evidence.evidenceState === 'PARTIAL' ? contracts.evidenceStatus !== 200 : contracts.evidenceStatus !== 503) throw new Error(vp.name+' evidence transport/state mismatch');
+  if (!['MEASURED','UNAVAILABLE'].includes(contracts.version.evidenceState)) throw new Error(vp.name+' unexpected version evidence state '+contracts.version.evidenceState);
+  if (!['PARTIAL','UNAVAILABLE'].includes(contracts.evidence.evidenceState)) throw new Error(vp.name+' unexpected evidence state '+contracts.evidence.evidenceState);
+  if (!verification.includes('STRUCTURAL-ONLY')) throw new Error(vp.name+' receipt verdict '+verification);
+  return {viewport:vp.name, overview, capabilityCount, dependencyCount, dependencyStates, endpointTexts, contracts, verification};
+}
+
+(async()=>{
+  const browser = await chromium.launch({executablePath:EDGE,headless:true,args:['--use-gl=angle','--use-angle=swiftshader','--ignore-gpu-blocklist','--enable-unsafe-swiftshader']});
+  try {
+    const results=[];
+    for (const vp of VIEWPORTS) results.push(await run(browser,vp));
+    console.log(JSON.stringify(results,null,2));
+  } finally {
+    await browser.close();
+  }
+})().catch(err=>{ console.error(err); process.exit(1); });

tests/test_hf_sync_contract.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+import unittest
+
+
+WORKFLOW = Path(".github/workflows/hf-sync.yml")
+README = Path("README.md")
+
+
+class HfSyncContractTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.workflow = WORKFLOW.read_text(encoding="utf-8")
+        cls.readme = README.read_text(encoding="utf-8")
+
+    def test_runtime_files_are_in_upload_contract(self) -> None:
+        for path in ("Dockerfile", ".dockerignore", "server.py", "organ_integrity.py"):
+            self.assertIn(f'"{path}"', self.workflow, path)
+        self.assertIn('"*.html"', self.workflow)
+        self.assertNotIn('"index.html", "live-body.html"', self.workflow)
+
+    def test_every_main_push_schedules_a_replacement_deploy(self) -> None:
+        push_trigger = self.workflow.split("workflow_dispatch:", 1)[0]
+        self.assertNotIn("paths:", push_trigger)
+        self.assertIn("group: anatomy-hf-sync", self.workflow)
+        self.assertIn("cancel-in-progress: false", self.workflow)
+
+    def test_release_tooling_is_exactly_pinned(self) -> None:
+        self.assertIn("huggingface_hub==1.23.0", self.workflow)
+        self.assertNotIn("huggingface_hub>=", self.workflow)
+
+    def test_release_waits_for_exact_live_revision(self) -> None:
+        self.assertIn("info.sha == target_sha", self.workflow)
+        self.assertIn('stage == "RUNNING"', self.workflow)
+        self.assertIn('"BUILD_ERROR"', self.workflow)
+        self.assertIn('/version?refresh=1', self.workflow)
+        self.assertIn('/.well-known/szl-source.json?refresh=1', self.workflow)
+        self.assertIn('source["deployment"]["hf_revision"] == target_sha', self.workflow)
+        self.assertIn('source["source"]["commit"] == source_revision', self.workflow)
+        self.assertIn(
+            'source["alignment_state"] == "SOURCE_BOUND_DEPLOYMENT"',
+            self.workflow,
+        )
+        self.assertIn(
+            'source["deployment"]["workflow_run_id"] == workflow_run_id',
+            self.workflow,
+        )
+
+    def test_release_generates_exact_source_manifest(self) -> None:
+        self.assertIn('"schema": "szl.hf-deploy-manifest/v1"', self.workflow)
+        self.assertIn('"source_repository": "szl-holdings/anatomy"', self.workflow)
+        self.assertIn('"source_revision": source_revision', self.workflow)
+        self.assertIn('"workflow_run_id": workflow_run_id', self.workflow)
+        self.assertIn('path_in_repo="hf-deploy-manifest.json"', self.workflow)
+        self.assertIn(
+            'commit_message=f"hf-sync: source {source_revision} run {workflow_run_id}"',
+            self.workflow,
+        )
+        self.assertNotIn("os.environ.get('GITHUB_SHA','')[:8]", self.workflow)
+
+    def test_release_binds_manifest_to_hf_commit_metadata(self) -> None:
+        self.assertIn('workflow_run_id = os.environ.get("GITHUB_RUN_ID", "")', self.workflow)
+        self.assertIn('if not workflow_run_id.isdigit():', self.workflow)
+        self.assertIn(
+            'f"hf-sync: source {source_revision} run {workflow_run_id}"',
+            self.workflow,
+        )
+
+    def test_release_rechecks_exact_current_main_at_mutation_boundary(self) -> None:
+        for contract in (
+            "GITHUB_TOKEN: ${{ github.token }}",
+            'source_ref != "refs/heads/main"',
+            'github_repo != "szl-holdings/anatomy"',
+            'f"/repos/{github_repo}/commits/main"',
+            "current_main != source_revision",
+        ):
+            self.assertIn(contract, self.workflow)
+        self.assertLess(
+            self.workflow.index("current_main != source_revision"),
+            self.workflow.index("api.create_commit("),
+        )
+
+    def test_release_verifies_public_health(self) -> None:
+        self.assertIn('base + "/healthz"', self.workflow)
+        self.assertIn('health["transport_state"] == "REACHABLE"', self.workflow)
+        self.assertIn('health["verification_state"] == "STRUCTURAL_ONLY"', self.workflow)
+
+    def test_release_verifies_public_version_and_evidence(self) -> None:
+        for contract in (
+            'base + "/version?refresh=1"',
+            'base + "/evidence?refresh=1"',
+            'version["gitSha"] == source_revision',
+            'version["deploymentRevision"] == target_sha',
+            'version["evidenceState"] == "MEASURED"',
+            'evidence["gitSha"] == source_revision',
+            'evidence["evidenceState"] == "PARTIAL"',
+            'evidence["source"]["deployment"]["hf_revision"] == target_sha',
+            'evidence["receipts"][0]["status"] == "STRUCTURAL_ONLY"',
+            'evidence["outputProvenance"]["authenticityEstablished"] is False',
+        ):
+            self.assertIn(contract, self.workflow)
+
+    def test_stale_space_only_docker_claim_is_absent(self) -> None:
+        self.assertNotIn("does not exist in this repo", self.workflow)
+        self.assertNotIn("Space-only Dockerfile", self.workflow)
+
+    def test_archived_uds_source_is_not_advertised(self) -> None:
+        self.assertNotIn(
+            "https://github.com/szl-holdings/szl-uds-deployment",
+            self.readme,
+        )
+        for active_source in ("a11oy", "killinchu", "szl-mesh"):
+            self.assertIn(
+                f"https://github.com/szl-holdings/{active_source}",
+                self.readme,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)