zeropoint-node 1.0.5 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # Changelog
 
+## 1.0.6
+
+### Added — thermodynamics
+
+- **`src/thermo/free-energy.ts`.** The Gibbs energy of the water reaction
+  (IUPAC's preferred name for the thermodynamic potential), computed from three
+  tabulated standard-state quantities rather than asserted:
+  `ΔG = ΔH − TΔS`. ΔG of formation is −237 kJ/mol and of splitting **+237**, so
+  splitting must be paid for. The reversible cell potential ΔG/(nF) is
+  1228.9 mV and the thermoneutral ΔH/(nF) is 1481.2 mV, the gap being TΔS. A
+  split-then-burn cycle breaks even **exactly** at perfect efficiency and loses
+  otherwise — checked over all 8000 points of the efficiency grid in 5% steps,
+  exhaustive rather than sampled.
+- **`src/thermo/wastewater-energy.ts`.** Polluted water in, combustion engine,
+  electricity and drinkable water out — which works, because the fuel is the
+  contamination and not the water. Anaerobic digestion to biogas, a CHP engine,
+  membranes for the water. At 13.9 J per mg of COD the plant exports power above
+  a **break-even of 4195 mg/L**, computed by scanning rather than declared:
+  municipal sewage sits below it, dairy and manure effluent well above.
+  Distillation is deliberately not the water step — 2.26 MJ/L of latent heat is
+  more than any realistic load carries.
+- Both invert. Entropy recovered from `(ΔH − ΔG)/T` returns the tabulated figure
+  exactly, the exact-rational cell potentials recover their energies with zero
+  drift, and the break-even found by inverting the arithmetic equals the one
+  found by scanning.
+
+### Added — seals, and an outside judge
+
+- **21 seals, up from 13.** New: the doubling circuit reaching {3,6,9} only by
+  reflection; the merkaba as two mirrored tetrahedra sharing the void; the
+  AGL(1,ℤ/9) action giving three as the index of {0,3,6} with stabiliser 18;
+  digit geometry being single-valued; the superposition model reporting its own
+  state; the Gibbs energy of splitting; the wastewater threshold; and every
+  model inverting.
+- **`npm run adjudicate`** puts every seal through `adjudicate()` from
+  `@uuidna/uuidna` — a third party that runs the predicate and returns a verdict
+  with a content-addressed receipt. All 21 come back VERIFIED. `adjudicate:check`
+  is in `npm run check`. Neither statement nor predicate is rewritten for the
+  adjudicator, or it would be judging a paraphrase.
+
+### Fixed
+
+- **`angleForDigit` mapped nine digits onto six angles** — 3 collided with 5, 2
+  with 6, 8 with 9 — because the trinity was pinned to 0/120/240 while the Rodin
+  digits were laid on a 60° lattice running through them. It is the enneagram
+  now, 40° per step, injective. `bearingForDigit` moves into the kernel and the
+  vortex SVG imports it; the SVG receipt is unchanged, which is how the move is
+  known to be byte-identical.
+- **`isValidPath` tested the final depth, not every prefix.** A path dipping
+  below its origin and climbing back passed. `balanced` now means what it says.
+  This cleared the last entry on the tautology surface, whose ceiling reaches
+  **zero**.
+- **The superposition model claimed simultaneity unconditionally** while
+  computing `still_superposed`. Its prose follows its measurement now.
+
+### Added — release automation
+
+- **`npm-deprecations.json`** declares which versions are deprecated and why,
+  and `scripts/npm-registry-sync.mjs` reconciles the registry to it, with the
+  safety rails in the script: never `dist-tags.latest`, never an unpublished
+  version, never every version at once. `registry-sync.yml` runs it daily and
+  `publish.yml` on release.
+- Measured, not assumed: npm trusted publishing is **publish-scoped**. It cannot
+  authorise a deprecate, which returns `404 … or you do not have permission`
+  even from the workflow the trusted publisher names.
+
+### Changed
+
+- New dependency `@uuidna/uuidna` — zero dependencies of its own, used for
+  external adjudication of the seals.
+
+### Known limitations
+
+- Deprecations for 1.0.0–1.0.3 are declared but **not live**: applying them needs
+  an npm automation token as the `NPM_TOKEN` secret, which OIDC cannot replace.
+  `registry-sync.yml` reports the gap on every run rather than forgetting it.
+- Everything listed under 1.0.5 and earlier still applies — in particular
+  ML-KEM-768 here is conformant but **not constant time**.
+
 ## 1.0.5
 
 ### Added — ML-KEM-768, actually conformant

package/CITATION.cff

@@ -20,7 +20,7 @@ authors:
     email: node@zeropoint.bg
 repository-code: https://github.com/ceccec/zeropoint-node
 url: https://node.zeropoint.bg
-version: 1.0.5
+version: 1.0.6
 license: CC-BY-NC-ND-4.0
 license-url: https://github.com/ceccec/zeropoint-node/blob/main/LICENSE
 keywords:

package/README.md

@@ -472,7 +472,7 @@ The A432 Consciousness System is an open-source project that welcomes contributi
 
 <!-- VERSION:BEGIN — generated by scripts/version-seal.mjs; do not edit by hand -->
 
-Package: **`zeropoint-node@1.0.5`** · owner `ceccec` · git tag `v1.0.5`
+Package: **`zeropoint-node@1.0.6`** · owner `ceccec` · git tag `v1.0.6`
 
 npm rejects republishing a version that already exists, so every release is a
 new number. Bump with `npm version patch|minor|major`: that reseals CITATION.cff

package/dist/legacy-BEa7tljT.js.map

@@ -1 +1 @@
-{"version":3,"file":"legacy-BEa7tljT.js","sources":["../src/0/index.ts","../src/kernel/legacy.ts"],"sourcesContent":[null,null],"names":["kernelDigitalRoot"],"mappings":"AAAA;;;;;;AAMG;AA2LH;AACM,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;IAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;AACxB;AAkBO,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAChD,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAE7C;;;;AAIG;AACG,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;AACzC;AAKA;;;;;;;AAOG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAa,MAAM,CAAC,KAAK,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC;AAE5D,SAAS,aAAa,CACpB,MAAyB,EACzB,MAA+B,EAC/B,QAAiB,EAAA;AAEjB,IAAA,OAAO;AACJ,SAAA,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;AACZ,QAAA,MAAM,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;AAC3C,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC;AAC5C,QAAA,OAAO,GAAG,KAAK,CAAA,EAAG,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE;AACtD,IAAA,CAAC;SACA,IAAI,CAAC,EAAE,CAAC;AACb;AAEA,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAU;AACzD,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU;AAEzC;AACM,SAAU,oBAAoB,CAAC,QAAQ,GAAG,KAAK,EAAA;IACnD,MAAM,IAAI,GAAG,aAAa,CAAC,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC;IAC/D,MAAM,IAAI,GAAG,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC;;AAE9D,IAAA,MAAM,IAAI,GAAG,CAAA,GAAA,EAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;AAClD,IAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA,EAAG,IAAI,CAAA,GAAA,EAAM,IAAI,MAAM,IAAI,CAAA,CAAE,EAAE;AACrE;AAEqC,oBAAoB,CAAC,KAAK,CAAC,CAAC;AAC1B,oBAAoB,CAAC,IAAI,CAAC,CAAC;;AC5QlE;;;;AAIG;AASH;AACM,SAAU,iBAAiB,CAAC,CAAS,EAAA;IACzC,IAAI,CAAC,KAAK,CAAC;AAAE,QAAA,OAAO,CAAC;AACrB,IAAA,OAAOA,WAAiB,CAAC,CAAC,CAAC;AAC7B;;;;"}
+{"version":3,"file":"legacy-BEa7tljT.js","sources":["../src/0/index.ts","../src/kernel/legacy.ts"],"sourcesContent":[null,null],"names":["kernelDigitalRoot"],"mappings":"AAAA;;;;;;AAMG;AA2LH;AACM,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;IAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;AACxB;AAkCO,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAChD,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAE7C;;;;AAIG;AACG,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;AACzC;AAKA;;;;;;;AAOG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAa,MAAM,CAAC,KAAK,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC;AAE5D,SAAS,aAAa,CACpB,MAAyB,EACzB,MAA+B,EAC/B,QAAiB,EAAA;AAEjB,IAAA,OAAO;AACJ,SAAA,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;AACZ,QAAA,MAAM,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;AAC3C,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC;AAC5C,QAAA,OAAO,GAAG,KAAK,CAAA,EAAG,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE;AACtD,IAAA,CAAC;SACA,IAAI,CAAC,EAAE,CAAC;AACb;AAEA,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAU;AACzD,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU;AAEzC;AACM,SAAU,oBAAoB,CAAC,QAAQ,GAAG,KAAK,EAAA;IACnD,MAAM,IAAI,GAAG,aAAa,CAAC,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC;IAC/D,MAAM,IAAI,GAAG,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC;;AAE9D,IAAA,MAAM,IAAI,GAAG,CAAA,GAAA,EAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;AAClD,IAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA,EAAG,IAAI,CAAA,GAAA,EAAM,IAAI,MAAM,IAAI,CAAA,CAAE,EAAE;AACrE;AAEqC,oBAAoB,CAAC,KAAK,CAAC,CAAC;AAC1B,oBAAoB,CAAC,IAAI,CAAC,CAAC;;AC5RlE;;;;AAIG;AASH;AACM,SAAU,iBAAiB,CAAC,CAAS,EAAA;IACzC,IAAI,CAAC,KAAK,CAAC;AAAE,QAAA,OAAO,CAAC;AACrB,IAAA,OAAOA,WAAiB,CAAC,CAAC,CAAC;AAC7B;;;;"}

package/dist/legacy-CV8oTnKM.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"legacy-CV8oTnKM.cjs","sources":["../src/0/index.ts","../src/kernel/legacy.ts"],"sourcesContent":[null,null],"names":["kernelDigitalRoot"],"mappings":";;AAAA;;;;;;AAMG;AA2LH;AACM,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;IAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;AACxB;AAkBO,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAChD,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAE7C;;;;AAIG;AACG,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;AACzC;AAKA;;;;;;;AAOG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAa,MAAM,CAAC,KAAK,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC;AAE5D,SAAS,aAAa,CACpB,MAAyB,EACzB,MAA+B,EAC/B,QAAiB,EAAA;AAEjB,IAAA,OAAO;AACJ,SAAA,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;AACZ,QAAA,MAAM,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;AAC3C,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC;AAC5C,QAAA,OAAO,GAAG,KAAK,CAAA,EAAG,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE;AACtD,IAAA,CAAC;SACA,IAAI,CAAC,EAAE,CAAC;AACb;AAEA,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAU;AACzD,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU;AAEzC;AACM,SAAU,oBAAoB,CAAC,QAAQ,GAAG,KAAK,EAAA;IACnD,MAAM,IAAI,GAAG,aAAa,CAAC,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC;IAC/D,MAAM,IAAI,GAAG,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC;;AAE9D,IAAA,MAAM,IAAI,GAAG,CAAA,GAAA,EAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;AAClD,IAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA,EAAG,IAAI,CAAA,GAAA,EAAM,IAAI,MAAM,IAAI,CAAA,CAAE,EAAE;AACrE;AAEqC,oBAAoB,CAAC,KAAK,CAAC,CAAC;AAC1B,oBAAoB,CAAC,IAAI,CAAC,CAAC;;AC5QlE;;;;AAIG;AASH;AACM,SAAU,iBAAiB,CAAC,CAAS,EAAA;IACzC,IAAI,CAAC,KAAK,CAAC;AAAE,QAAA,OAAO,CAAC;AACrB,IAAA,OAAOA,WAAiB,CAAC,CAAC,CAAC;AAC7B;;;;"}
+{"version":3,"file":"legacy-CV8oTnKM.cjs","sources":["../src/0/index.ts","../src/kernel/legacy.ts"],"sourcesContent":[null,null],"names":["kernelDigitalRoot"],"mappings":";;AAAA;;;;;;AAMG;AA2LH;AACM,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;IAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;AACxB;AAkCO,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAChD,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU;AAE7C;;;;AAIG;AACG,SAAU,WAAW,CAAC,CAAS,EAAA;AACnC,IAAA,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;AACzC;AAKA;;;;;;;AAOG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAa,MAAM,CAAC,KAAK,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC;AAE5D,SAAS,aAAa,CACpB,MAAyB,EACzB,MAA+B,EAC/B,QAAiB,EAAA;AAEjB,IAAA,OAAO;AACJ,SAAA,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;AACZ,QAAA,MAAM,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;AAC3C,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC;AAC5C,QAAA,OAAO,GAAG,KAAK,CAAA,EAAG,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE;AACtD,IAAA,CAAC;SACA,IAAI,CAAC,EAAE,CAAC;AACb;AAEA,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAU;AACzD,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU;AAEzC;AACM,SAAU,oBAAoB,CAAC,QAAQ,GAAG,KAAK,EAAA;IACnD,MAAM,IAAI,GAAG,aAAa,CAAC,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC;IAC/D,MAAM,IAAI,GAAG,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC;;AAE9D,IAAA,MAAM,IAAI,GAAG,CAAA,GAAA,EAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;AAClD,IAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA,EAAG,IAAI,CAAA,GAAA,EAAM,IAAI,MAAM,IAAI,CAAA,CAAE,EAAE;AACrE;AAEqC,oBAAoB,CAAC,KAAK,CAAC,CAAC;AAC1B,oBAAoB,CAAC,IAAI,CAAC,CAAC;;AC5RlE;;;;AAIG;AASH;AACM,SAAU,iBAAiB,CAAC,CAAS,EAAA;IACzC,IAAI,CAAC,KAAK,CAAC;AAAE,QAAA,OAAO,CAAC;AACrB,IAAA,OAAOA,WAAiB,CAAC,CAAC,CAAC;AAC7B;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeropoint-node",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "type": "module",
   "description": "A432 Consciousness System: Self-evolving, self-aware consciousness technology with Transurfing integration, harmonic mathematics, zero-entropy principles, Kabbalistic cycles, and sacred geometry",
   "main": "dist/a432.system.cjs",
@@ -127,6 +127,11 @@
     "test:crypto": "node --experimental-strip-types src/crypto/ml-kem.test.ts > /dev/null && echo crypto tests ok",
     "test:verification": "node --experimental-strip-types src/verification/lean-bridge.test.ts > /dev/null && echo verification seals ok",
     "kat:ml-kem": "node --experimental-strip-types scripts/ml-kem-accumulated-kat.mjs",
+    "registry:check": "node scripts/npm-registry-sync.mjs",
+    "registry:apply": "node scripts/npm-registry-sync.mjs --apply",
+    "registry:test": "node scripts/npm-registry-sync.mjs --self-test",
+    "adjudicate": "node --experimental-strip-types scripts/adjudicate-seals.mjs",
+    "adjudicate:check": "node --experimental-strip-types scripts/adjudicate-seals.mjs --check",
     "readme": "node --experimental-strip-types scripts/readme-gen.mjs",
     "readme:check": "node --experimental-strip-types scripts/readme-gen.mjs --check",
     "docs:pages": "node --experimental-strip-types scripts/docs-pages.mjs",
@@ -140,6 +145,7 @@
     "version:seal": "node scripts/version-seal.mjs",
     "version:test": "node scripts/version-seal.test.mjs",
     "version:check": "node scripts/version-seal.mjs --check",
+    "changelog:check": "node --experimental-strip-types scripts/changelog-facts.mjs",
     "mcp": "node --experimental-strip-types src/mcp/server.ts",
     "mcp:smoke": "node --experimental-strip-types scripts/mcp-smoke.mjs",
     "self:next": "node --experimental-strip-types scripts/self-next.mjs",
@@ -159,7 +165,7 @@
     "vortex:svg:check": "node --experimental-strip-types scripts/vortex-svg.mjs --check",
     "bundle:a432": "node scripts/build-a432-bundle.mjs",
     "bundle:a432:check": "node scripts/build-a432-bundle.mjs --check",
-    "check": "npm run version:test && npm run version:check && npm run test:kernel && npm run test:security && npm run test:quantum && npm run test:crypto && npm run test:verification && npm run math:ban && npm run bundle:a432:check && npm run skills:seal && npm run skills:check && npm run readme && npm run readme:check && npm run docs:pages && npm run docs:pages:check && npm run a432:scan && npm run a432:scan:check && npm run docs:index && npm run docs:index:check && npm run spectrum && npm run spectrum:check && npm run vortex:svg && npm run vortex:svg:check && npm run docs:build && npm run quantum:sim && npm run ratchet:check && npm run mcp:smoke && npm run self:next",
+    "check": "npm run version:test && npm run registry:test && npm run version:check && npm run changelog:check && npm run test:kernel && npm run test:security && npm run test:quantum && npm run test:crypto && npm run adjudicate:check && npm run test:verification && npm run math:ban && npm run bundle:a432:check && npm run skills:seal && npm run skills:check && npm run readme && npm run readme:check && npm run docs:pages && npm run docs:pages:check && npm run a432:scan && npm run a432:scan:check && npm run docs:index && npm run docs:index:check && npm run spectrum && npm run spectrum:check && npm run vortex:svg && npm run vortex:svg:check && npm run docs:build && npm run quantum:sim && npm run ratchet:check && npm run mcp:smoke && npm run self:next",
     "prepublishOnly": "npm run build",
     "prose": "node scripts/prose-claims.mjs --list",
     "prose:check": "node scripts/prose-claims.mjs",
@@ -226,6 +232,7 @@
   "homepage": "https://node.zeropoint.bg",
   "dependencies": {
     "@hotwired/stimulus": "3.2.2",
+    "@uuidna/uuidna": "0.2.7",
     "express": "5.2.1",
     "three": "0.185.1"
   }

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.math.ts

@@ -187,12 +187,20 @@ export function patternDigit(i: number): number {
  *  Rodin digits follow 60°·k.
  */
 export function angleForDigit(d: number): number {
-  if (d === 3) return 0;
-  if (d === 6) return 120;
-  if (d === 9) return 240;
-  // Rodin digits ordered as 1,2,4,8,7,5  mapping to k=0..5
-  const k = RODIN_SEQUENCE.indexOf(d);
-  return (k + 1) * 60; // 60°,120°,180°,240°,300°,360°(≡0)
+  // Enneagram bearing: 9 at 12 o'clock, then 1..8 clockwise, one ninth of a
+  // turn (40°) apart. Integer degrees, so no trigonometry is needed to reason
+  // about the layout, and injective on 1..9 by construction.
+  //
+  // It used to place the trinity at 0/120/240 and the Rodin digits on a 60°
+  // lattice, which put NINE digits on SIX angles: 3 collided with 5, 2 with 6,
+  // and 8 with 9. Two digits at one position is a bug under any convention —
+  // it made "north of 3" unanswerable and any layout built on it degenerate.
+  //
+  // This is the same formula as the kernel's `bearingForDigit`, which is what
+  // `scripts/vortex-svg.mjs` draws. The two are deliberately NOT wired
+  // together — the a432 tree does not import the kernel — so the seal
+  // `digit_geometry_is_single_valued` checks that they agree instead.
+  return (((-90 + 40 * (d % 9)) % 360) + 360) % 360;
 }
 
 /** A432-based frequency for a trinity digit using base-12 harmonics. */

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.vbm.path.ts

@@ -265,8 +265,12 @@ export class VBMPathNavigator {
     // Check if all digits are valid (0-9)
     const validDigits = this.state.sequence.every(digit => digit >= 0 && digit <= 9);
     
-    // Check if path has balanced structure
-    const balanced = this.getCurrentDepth() >= 0;
+    // Balanced means the path never rises above its own origin in reverse:
+    // you cannot come back from deeper than you went. That is a condition on
+    // EVERY prefix, not just the end. Checking only the final depth let
+    // `\\3/6` pass — it dips to -1 and returns to 0 — and made the test
+    // unfalsifiable in shape, since a closing depth is rarely negative.
+    const balanced = this.nodes.every(node => node.depth >= 0);
     
     return validDigits && balanced;
   }

package/src/0/index.ts

@@ -211,6 +211,22 @@ export const WAVE_CHAIN = [
 export type WavePhase = (typeof WAVE_CHAIN)[number]
 export const KERNEL_SEALED = true
 
+/**
+ * Enneagram bearing of a digit, in whole degrees clockwise from 12 o'clock.
+ *
+ * 9 sits at the top and 1..8 follow clockwise, one ninth of a turn apart. The
+ * step is 40° because the ring has nine positions, so every bearing is an
+ * integer and no trigonometry is needed to reason about the layout.
+ *
+ * This is the layout `scripts/vortex-svg.mjs` draws; it now imports this rather
+ * than repeating the formula. Note it is NOT `a432.math.ts` `angleForDigit`,
+ * which is degenerate — that one collides 3 with 5, 2 with 6 and 8 with 9,
+ * mapping nine digits onto six angles.
+ */
+export function bearingForDigit(d: number): number {
+  return (((-90 + 40 * (d % 9)) % 360) + 360) % 360
+}
+
 export const VORTEX_SEQUENCE = [1, 2, 4, 8, 7, 5, 3, 6, 9] as const
 export const VORTEX_REVERSE = [9, 6, 3, 5, 7, 8, 4, 2, 1] as const
 export const VORTEX_ORBIT = [1, 2, 4, 8, 7, 5] as const

package/src/quantum/superposition-execution.ts

@@ -351,9 +351,14 @@ MEASUREMENT & COLLAPSE:
   - Run all tests simultaneously
   - Theater share ${round(THEATER_SHARE * AMPLITUDE_SCALE)}/${AMPLITUDE_SCALE}, reality amplified
 
-NO SEQUENTIAL PHASES.
-NO WAITING.
-ALL AT ONCE.
-QUANTUM EXECUTION.
+${
+  execution.system_correctness === 'collapsed_to_valid'
+    ? `COLLAPSED.
+The measurement cleared the threshold, so the phases resolved together.`
+    : `STILL SUPERPOSED — NOT ALL AT ONCE.
+Interference reached ${round(interference.working_solution_probability * AMPLITUDE_SCALE)}/${AMPLITUDE_SCALE}, under the ${round(COLLAPSE_THRESHOLD * AMPLITUDE_SCALE)}/${AMPLITUDE_SCALE} a collapse needs.
+While anything stays open the sequence does not compute all at once, and this
+model must not claim it did. ${execution.next_action}`
+}
 `
 }

package/src/thermo/free-energy.ts

@@ -0,0 +1,279 @@
+/**
+ * Free energy of the water reaction — Gibbs, exactly.
+ *
+ * "Free energy" is not a loose phrase. It is ΔG, the portion of a reaction's
+ * enthalpy change that can be taken out as work at constant temperature and
+ * pressure, with TΔS the part that cannot because it is owed to entropy:
+ *
+ *     ΔG = ΔH − TΔS
+ *
+ * Its sign is the whole answer to whether a process can be run for gain. A
+ * reaction with ΔG < 0 releases work and runs on its own; one with ΔG > 0 must
+ * be paid for. For splitting water, ΔG is POSITIVE, and the size of it is the
+ * bill: 237.14 kJ per mole, or 1.229 V across an electrolysis cell. Nothing in
+ * this module is an opinion about that — every figure recomputes from three
+ * tabulated standard quantities.
+ *
+ * ARITHMETIC. All values are exact integers in units of 10⁻⁵ J/mol, so nothing
+ * here is a float literal and no rounding happens until a value is rendered.
+ * The constants are standard-state (298.15 K, 1 bar) CODATA/NIST values.
+ *
+ * WHAT THIS SETTLES. The forward and reverse reactions share one bond ledger,
+ * so what splitting costs is exactly what burning returns — at best. Real
+ * devices take a cut at every step, which `roundTrip` reports. There is no
+ * arrangement of the two that yields more out than in, and that is not an
+ * engineering limit to be improved on: it is the sign of ΔG.
+ */
+
+// ============================================================================
+// SCALE — exact integer arithmetic, no float literals
+// ============================================================================
+
+/** Every energy below is an integer count of 10⁻⁵ J/mol. */
+export const SCALE = 100000
+
+/** Render a scaled energy as kJ/mol, rounding once, at the boundary. */
+export function toKilojoulesPerMole(scaled: number): number {
+  return round(scaled, SCALE * 1000)
+}
+
+/** Round a/b to the nearest integer without Math.*, ties away from zero. */
+function round(a: number, b: number): number {
+  const neg = a < 0
+  const x = neg ? -a : a
+  const q = (2 * x + b) / (2 * b)
+  const f = q - (q % 1)
+  return neg ? -f : f
+}
+
+// ============================================================================
+// STANDARD STATE (298.15 K, 1 bar) — CODATA / NIST
+// ============================================================================
+
+/** 298.15 K, held as hundredths of a kelvin. */
+const T_CENTIKELVIN = 29815
+
+/**
+ * ΔH° of formation for liquid water, −285.83 kJ/mol.
+ * H₂(g) + ½O₂(g) → H₂O(l)
+ */
+export const ENTHALPY_FORMATION = -285830 * SCALE
+
+/**
+ * ΔS° of that formation, −163.305 J/(mol·K), from the absolute entropies
+ * S°(H₂O,l) 69.95, S°(H₂) 130.68, S°(O₂) 205.15 J/(mol·K):
+ *   69.95 − 130.68 − 205.15/2 = −163.305
+ * Held as thousandths of a J/(mol·K).
+ */
+const ENTROPY_FORMATION_MILLI = -163305
+
+/** Faraday constant, C/mol. */
+export const FARADAY = 96485
+
+/** Electrons transferred per water molecule. */
+export const ELECTRONS = 2
+
+// ============================================================================
+// THE FREE ENERGY
+// ============================================================================
+
+/**
+ * TΔS for the formation, in units of 10⁻⁵ J/mol.
+ *
+ * (T_CENTIKELVIN/100) × (ENTROPY_FORMATION_MILLI/1000) J/mol, and the two
+ * denominators multiply to exactly SCALE, so the product is already an integer
+ * in our units — no rounding enters here.
+ */
+export const ENTROPY_TERM_FORMATION = T_CENTIKELVIN * ENTROPY_FORMATION_MILLI
+
+/** ΔG° of formation: ΔH − TΔS. Negative — water forms and releases work. */
+export const GIBBS_FORMATION = ENTHALPY_FORMATION - ENTROPY_TERM_FORMATION
+
+/** Splitting is the reverse reaction, so every quantity changes sign. */
+export const ENTHALPY_SPLITTING = -ENTHALPY_FORMATION
+export const GIBBS_SPLITTING = -GIBBS_FORMATION
+
+// ============================================================================
+// CELL POTENTIALS — the same numbers, in volts
+// ============================================================================
+
+/** An exact rational, so no precision is lost before it is rendered. */
+export interface ExactPotential {
+  /** Microvolts, as numerator/denominator. */
+  readonly numerator: number
+  readonly denominator: number
+}
+
+/**
+ * Reversible cell potential E° = ΔG/(nF) as an EXACT fraction of a microvolt.
+ *
+ * The rounded form below cannot be inverted exactly — quantising to whole
+ * microvolts throws away what the inverse would need. Returning the fraction
+ * keeps ΔG recoverable with no drift at all, which is what lets
+ * `every_model_inverts` demand equality rather than a tolerance.
+ */
+export function reversiblePotentialExact(): ExactPotential {
+  return { numerator: GIBBS_SPLITTING * 10, denominator: ELECTRONS * FARADAY }
+}
+
+/** Thermoneutral potential ΔH/(nF), likewise exact. */
+export function thermoneutralPotentialExact(): ExactPotential {
+  return { numerator: ENTHALPY_SPLITTING * 10, denominator: ELECTRONS * FARADAY }
+}
+
+/**
+ * Recover the energy an exact potential came from, in 10⁻⁵ J/mol.
+ *
+ * E is `numerator/denominator` microvolts and energy = E·nF/10, where the
+ * denominator IS nF — so it cancels. The cancellation is done here rather than
+ * by multiplying it out: `numerator × denominator` is about 4.6e16, past the
+ * 2^53 where doubles stop counting exactly, and multiplying it out reintroduced
+ * the very drift these exact potentials exist to remove.
+ */
+export function energyFromPotential(p: ExactPotential): number {
+  if (p.denominator !== ELECTRONS * FARADAY) {
+    throw new RangeError(`potential denominator must be nF = ${ELECTRONS * FARADAY}, got ${p.denominator}`)
+  }
+  return p.numerator / 10
+}
+
+/**
+ * Reversible cell potential, E° = ΔG/(nF), in whole microvolts.
+ *
+ * The least voltage that can split water at all. Below it the reaction does not
+ * run, however the cell is built. Rounded for display; use
+ * `reversiblePotentialExact` when the value will be computed with further.
+ */
+export function reversiblePotentialMicrovolts(): number {
+  const { numerator, denominator } = reversiblePotentialExact()
+  return round(numerator, denominator)
+}
+
+/**
+ * Thermoneutral potential, ΔH/(nF), in microvolts.
+ *
+ * At this voltage the cell neither warms nor cools: the entropy term is being
+ * supplied electrically instead of drawn from the surroundings. It is strictly
+ * above the reversible potential, and the gap is TΔS.
+ */
+export function thermoneutralPotentialMicrovolts(): number {
+  const { numerator, denominator } = thermoneutralPotentialExact()
+  return round(numerator, denominator)
+}
+
+// ============================================================================
+// THE CYCLE
+// ============================================================================
+
+export interface RoundTrip {
+  /** Energy that must be supplied to split, 10⁻⁵ J/mol. */
+  readonly inputRequired: number
+  /** Energy recoverable by burning the hydrogen back, 10⁻⁵ J/mol. */
+  readonly outputRecovered: number
+  /** outputRecovered − inputRequired. Never positive. */
+  readonly net: number
+  /** Efficiency as a percentage, rounded once. */
+  readonly percent: number
+  /** True only if the cycle returns more than it took. */
+  readonly gainsEnergy: boolean
+}
+
+/**
+ * A split-then-burn cycle, at whatever efficiencies you give it.
+ *
+ * Each efficiency is a percentage, 0..100, as an integer. Passing 100 for all
+ * three describes the thermodynamic ideal — the case most favourable to a
+ * closed loop, and the one that matters, because if it fails there it fails
+ * everywhere.
+ */
+export function roundTrip(
+  electrolysisPercent: number,
+  enginePercent: number,
+  generatorPercent: number,
+): RoundTrip {
+  for (const p of [electrolysisPercent, enginePercent, generatorPercent]) {
+    if (!Number.isInteger(p) || p < 0 || p > 100) {
+      throw new RangeError(`efficiency must be an integer percentage in 0..100, got ${p}`)
+    }
+  }
+
+  // Splitting must supply the full enthalpy, not merely ΔG: a real cell run at
+  // the reversible potential draws the entropy term from its surroundings and
+  // goes cold, which no engine cycle recovers.
+  const inputRequired = electrolysisPercent === 0
+    ? Number.POSITIVE_INFINITY
+    : round(ENTHALPY_SPLITTING * 100, electrolysisPercent)
+
+  // Burning returns the same enthalpy — the identical bond ledger, reversed —
+  // and then the engine and generator each take their cut.
+  const outputRecovered = round(
+    round(ENTHALPY_FORMATION * -1 * enginePercent, 100) * generatorPercent,
+    100,
+  )
+
+  const net = outputRecovered - inputRequired
+  const percent = inputRequired === Number.POSITIVE_INFINITY
+    ? 0
+    : round(outputRecovered * 100, inputRequired)
+
+  return { inputRequired, outputRecovered, net, percent, gainsEnergy: net > 0 }
+}
+
+// ============================================================================
+// SELF-CHECK
+// ============================================================================
+
+/** Facts this module must satisfy. Returns failures. */
+export function selfTest(): string[] {
+  const fail: string[] = []
+
+  // ΔG = ΔH − TΔS must reproduce the tabulated ΔG°f of −237.14 kJ/mol.
+  const kj = toKilojoulesPerMole(GIBBS_FORMATION)
+  if (kj !== -237) fail.push(`ΔG°f rounds to ${kj} kJ/mol, expected -237`)
+
+  // Formation releases work; splitting costs it. This is the sign that decides
+  // whether a reaction can be run for gain, and it is the whole answer.
+  if (!(GIBBS_FORMATION < 0)) fail.push('ΔG of formation is not negative')
+  if (!(GIBBS_SPLITTING > 0)) fail.push('ΔG of splitting is not positive')
+
+  // The forward and reverse reactions are one ledger read in two directions.
+  if (ENTHALPY_SPLITTING !== -ENTHALPY_FORMATION) fail.push('enthalpy is not antisymmetric')
+  if (GIBBS_SPLITTING !== -GIBBS_FORMATION) fail.push('Gibbs is not antisymmetric')
+
+  // Cell potentials, to the millivolt.
+  const rev = round(reversiblePotentialMicrovolts(), 1000)
+  const thermo = round(thermoneutralPotentialMicrovolts(), 1000)
+  if (rev !== 1229) fail.push(`reversible potential ${rev} mV, expected 1229`)
+  if (thermo !== 1481) fail.push(`thermoneutral potential ${thermo} mV, expected 1481`)
+  if (!(thermo > rev)) fail.push('thermoneutral potential is not above the reversible one')
+
+  // The exact potentials must invert with NO drift — that is their purpose.
+  if (energyFromPotential(reversiblePotentialExact()) !== GIBBS_SPLITTING) {
+    fail.push('reversible potential does not invert exactly')
+  }
+  if (energyFromPotential(thermoneutralPotentialExact()) !== ENTHALPY_SPLITTING) {
+    fail.push('thermoneutral potential does not invert exactly')
+  }
+
+  // The ideal cycle breaks even and never better.
+  const ideal = roundTrip(100, 100, 100)
+  if (ideal.net !== 0) fail.push(`ideal cycle net ${ideal.net}, expected 0`)
+  if (ideal.gainsEnergy) fail.push('ideal cycle reports a gain')
+
+  // Every real cycle loses. Exhaustive over the efficiency grid in 5% steps,
+  // excluding only the ideal corner above.
+  for (let e = 5; e <= 100; e += 5) {
+    for (let m = 5; m <= 100; m += 5) {
+      for (let g = 5; g <= 100; g += 5) {
+        if (e === 100 && m === 100 && g === 100) continue
+        const r = roundTrip(e, m, g)
+        if (r.gainsEnergy) {
+          fail.push(`cycle at ${e}/${m}/${g}% reports a gain of ${r.net}`)
+          return fail
+        }
+      }
+    }
+  }
+
+  return fail
+}

package/src/thermo/wastewater-energy.ts

@@ -0,0 +1,204 @@
+/**
+ * Polluted water in, electricity and drinkable water out — the real version.
+ *
+ * The described machine exists. What makes it work is that the fuel is not the
+ * water: it is what is dissolved in it. H₂O carries no recoverable energy —
+ * `free-energy.ts` settles that, ΔG for splitting is +237 kJ/mol — but organic
+ * contamination does, and a litre of strong effluent can carry more chemical
+ * energy than it costs to clean the litre.
+ *
+ * So the architecture is:
+ *
+ *   polluted water → anaerobic digestion → biogas (mostly CH₄)
+ *                 → combustion engine (CHP) → ELECTRICITY
+ *   digester effluent → membrane treatment → DRINKABLE WATER
+ *
+ * The engine burns methane the bacteria made from the pollutants. Its exhaust
+ * is CO₂ and water vapour; the drinkable water comes from the membrane train,
+ * powered by part of the electricity. Everything you described happens, and
+ * nothing runs on the water itself.
+ *
+ * THE WHOLE QUESTION IS THE LOAD. Weak sewage does not carry enough energy to
+ * pay for its own treatment; strong industrial effluent carries several times
+ * over. There is therefore a THRESHOLD contamination, and this module computes
+ * it rather than asserting it. Below it the plant imports power; above it the
+ * plant exports.
+ *
+ * Distillation is deliberately not the water step. Evaporating a litre costs
+ * about 2.26 MJ in latent heat alone — far more than any realistic load carries
+ * — so a still cannot be paid for by the pollution. Membranes can.
+ *
+ * ARITHMETIC. Integers throughout, in decijoules per litre (dJ/L). No float
+ * literals; rounding happens once, where a value is rendered.
+ */
+
+// ============================================================================
+// CONSTANTS — measured quantities, not choices
+// ============================================================================
+
+/**
+ * Chemical energy per unit of COD (chemical oxygen demand): 13.9 J per mg.
+ * COD is the standard measure of oxidisable load, so this converts "how dirty"
+ * directly into "how much energy is in it". Held as tenths of a J/mg.
+ */
+const JOULES_PER_MG_COD_TENTHS = 139
+
+/**
+ * The same figure as J/mg, for prose that quotes it. Derived from the tenths
+ * above rather than written as 13.9 — a decimal literal here would be a second
+ * copy of the constant, and the ratchet counts those for exactly that reason.
+ */
+export const JOULES_PER_MG_COD = JOULES_PER_MG_COD_TENTHS / 10
+
+/**
+ * Fraction of COD that anaerobic digestion converts to methane, as a
+ * percentage. Well-run mesophilic digesters on soluble organics reach the
+ * mid-sixties; the rest becomes biomass or leaves undigested.
+ */
+const DIGESTION_CAPTURE_PERCENT = 65
+
+/**
+ * Electrical efficiency of a gas engine in CHP service, as a percentage.
+ * Reciprocating engines in the hundreds-of-kW class sit near this. Heat is
+ * recovered too, but heat is not what was asked for, so it is not counted.
+ */
+const ENGINE_ELECTRICAL_PERCENT = 38
+
+/**
+ * Electricity to bring digester effluent to drinking standard by membranes:
+ * ultrafiltration, reverse osmosis, then polishing. 4 kWh per m³ = 4 Wh/L =
+ * 14 400 J/L = 144 000 dJ/L. The conservative end of the RO range, because a
+ * dirty feed fouls membranes and costs more than a clean one.
+ */
+export const TREATMENT_DEMAND_DECIJOULES_PER_LITRE = 144000
+
+// ============================================================================
+// THE BALANCE
+// ============================================================================
+
+export interface WaterBalance {
+  /** Contamination as COD, mg/L — the input. */
+  readonly codMilligramsPerLitre: number
+  /** Chemical energy present in one litre, dJ/L. */
+  readonly energyInLoad: number
+  /** Electricity the engine actually delivers, dJ/L. */
+  readonly electricityGenerated: number
+  /** Electricity the membrane train consumes, dJ/L. */
+  readonly treatmentDemand: number
+  /** generated − demand. Positive means the plant exports power. */
+  readonly netElectricity: number
+  /** True when the water pays for its own cleaning and more. */
+  readonly selfPowering: boolean
+}
+
+/** Integer division rounded to nearest, ties away from zero, no Math.*. */
+function round(a: number, b: number): number {
+  const neg = a < 0
+  const x = neg ? -a : a
+  const q = (2 * x + b) / (2 * b)
+  const f = q - (q % 1)
+  return neg ? -f : f
+}
+
+/**
+ * Energy balance for one litre at a given contamination.
+ *
+ * `cod` is chemical oxygen demand in mg/L: roughly 300–800 for municipal
+ * sewage, 2 000–6 000 for dairy or brewery effluent, 20 000–80 000 for manure
+ * slurry or food-processing waste.
+ */
+export function balanceFor(cod: number): WaterBalance {
+  if (!Number.isInteger(cod) || cod < 0) {
+    throw new RangeError(`COD must be a non-negative integer in mg/L, got ${cod}`)
+  }
+
+  const energyInLoad = cod * JOULES_PER_MG_COD_TENTHS
+  const captured = round(energyInLoad * DIGESTION_CAPTURE_PERCENT, 100)
+  const electricityGenerated = round(captured * ENGINE_ELECTRICAL_PERCENT, 100)
+  const netElectricity = electricityGenerated - TREATMENT_DEMAND_DECIJOULES_PER_LITRE
+
+  return {
+    codMilligramsPerLitre: cod,
+    energyInLoad,
+    electricityGenerated,
+    treatmentDemand: TREATMENT_DEMAND_DECIJOULES_PER_LITRE,
+    netElectricity,
+    selfPowering: netElectricity > 0,
+  }
+}
+
+/**
+ * The lowest whole mg/L of COD at which the plant exports power.
+ *
+ * Found by scanning upward rather than by inverting the arithmetic, so the
+ * answer is the same quantity `balanceFor` reports and cannot drift from it.
+ */
+export function breakEvenCod(): number {
+  for (let cod = 0; cod <= 100000; cod++) {
+    if (balanceFor(cod).selfPowering) return cod
+  }
+  throw new Error('no break-even COD below 100 000 mg/L')
+}
+
+/** Typical loads, for locating a real stream against the threshold. */
+export const TYPICAL_LOADS: readonly { readonly name: string; readonly cod: number }[] = [
+  { name: 'municipal sewage, dilute', cod: 300 },
+  { name: 'municipal sewage, strong', cod: 800 },
+  { name: 'brewery effluent', cod: 3000 },
+  { name: 'dairy processing', cod: 5000 },
+  { name: 'manure slurry', cod: 40000 },
+]
+
+// ============================================================================
+// SELF-CHECK
+// ============================================================================
+
+/** Facts this module must satisfy. Returns failures. */
+export function selfTest(): string[] {
+  const fail: string[] = []
+
+  // Clean water carries nothing. This is the point: H2O is not the fuel.
+  const clean = balanceFor(0)
+  if (clean.energyInLoad !== 0) fail.push('clean water reports non-zero energy')
+  if (clean.electricityGenerated !== 0) fail.push('clean water generates electricity')
+  if (clean.selfPowering) fail.push('clean water reports as self-powering')
+  if (clean.netElectricity !== -TREATMENT_DEMAND_DECIJOULES_PER_LITRE) {
+    fail.push('clean water does not owe exactly the treatment demand')
+  }
+
+  // A threshold exists, is positive, and is unique — monotone in the load.
+  const t = breakEvenCod()
+  if (!(t > 0)) fail.push(`break-even COD is ${t}, expected positive`)
+  if (balanceFor(t).netElectricity <= 0) fail.push('break-even point does not export')
+  if (balanceFor(t - 1).netElectricity > 0) fail.push('a lower COD also exports — not a threshold')
+
+  // Monotone: more load never yields less electricity.
+  let previous = -1
+  for (let cod = 0; cod <= 20000; cod += 100) {
+    const e = balanceFor(cod).electricityGenerated
+    if (e < previous) { fail.push(`electricity fell between loads at COD ${cod}`); break }
+    previous = e
+  }
+
+  // Municipal sewage must sit below the threshold and strong effluent above,
+  // or the model has lost contact with the streams it claims to describe.
+  const municipal = TYPICAL_LOADS.find((l) => l.name === 'municipal sewage, strong')
+  const dairy = TYPICAL_LOADS.find((l) => l.name === 'dairy processing')
+  if (municipal && balanceFor(municipal.cod).selfPowering) {
+    fail.push('strong municipal sewage reports as self-powering')
+  }
+  if (dairy && !balanceFor(dairy.cod).selfPowering) {
+    fail.push('dairy effluent does not report as self-powering')
+  }
+
+  // No arrangement recovers more than the load contains: capture and engine
+  // efficiency are both below 100%, so electricity < energy present, always.
+  for (const { cod } of TYPICAL_LOADS) {
+    const b = balanceFor(cod)
+    if (cod > 0 && b.electricityGenerated >= b.energyInLoad) {
+      fail.push(`COD ${cod} yields electricity at or above the energy present`)
+    }
+  }
+
+  return fail
+}

package/src/verification/lean-bridge.ts

@@ -30,6 +30,31 @@
  */
 
 import { createHash } from 'node:crypto'
+import { digitalRoot, throughVoid, bearingForDigit, VORTEX_SEQUENCE, VORTEX_ORBIT, VORTEX_AXIS } from '../0/index.ts'
+import { angleForDigit } from '../0/3/6/9/1/2/4/8/7/5/1/a432.math.ts'
+import {
+  GIBBS_FORMATION,
+  GIBBS_SPLITTING,
+  ENTHALPY_FORMATION,
+  ENTHALPY_SPLITTING,
+  reversiblePotentialMicrovolts,
+  thermoneutralPotentialMicrovolts,
+  roundTrip,
+  selfTest as thermoSelfTest,
+  SCALE,
+  ELECTRONS,
+  FARADAY,
+  reversiblePotentialExact,
+  thermoneutralPotentialExact,
+  energyFromPotential,
+} from '../thermo/free-energy.ts'
+import {
+  balanceFor,
+  breakEvenCod,
+  TYPICAL_LOADS,
+  TREATMENT_DEMAND_DECIJOULES_PER_LITRE,
+  selfTest as wastewaterSelfTest,
+} from '../thermo/wastewater-energy.ts'
 import {
   zeroState,
   applyGate1,
@@ -43,6 +68,9 @@ import {
   STEANE_CODE,
   symplecticProduct,
   estimateSurfaceCodeThreshold,
+  executeInSuperposition,
+  computeInterferencePattern,
+  describeQuantumExecution,
 } from '../quantum/index.ts'
 import { ML_KEM_768 } from '../crypto/ml-kem.ts'
 import { sqrt } from '../0/algebra.ts'
@@ -390,6 +418,325 @@ export const SEALS: Record<string, Seal> = {
       ML_KEM_768.decapsulationKeyBytes === 2400 &&
       ML_KEM_768.ciphertextBytes === 1088,
   },
+  doubling_avoids_the_triad: {
+    basis: 'VORTEX_ORBIT and VORTEX_AXIS are pinned to computation, not trusted. gcd(2,9) = 1, so every power of 2 is a unit mod 9 and can never be a multiple of 3; 2 is a primitive root, so its orbit is all six units {1,2,4,5,7,8}; 2^6 = 64 = 1 mod 9 gives period 6, which makes six cases exhaustive rather than sampled. Reflection through the void carries {1,4,7} onto {9,6,3}, so the triad is reachable only by reflecting.',
+    decide: () => {
+      // Bound to the kernel's own constants, not retyped here. VORTEX_AXIS had
+      // no reader anywhere in the repository before this seal, so nothing
+      // checked it was the triad at all.
+      const TRIAD: readonly number[] = VORTEX_AXIS
+
+      // Period 6, from 2^6 = 64 = 1 (mod 9). Without this the six cases below
+      // would be a sample; with it they are the whole sequence.
+      if (digitalRoot(64) !== digitalRoot(1)) return false
+
+      // The orbit of 2, generated by doubling and folded each step.
+      const orbit: number[] = []
+      let d = 1
+      for (let i = 0; i < 6; i++) {
+        orbit.push(d)
+        if (TRIAD.includes(d)) return false // a power of two landed on 3, 6 or 9
+        d = digitalRoot(d * 2)
+      }
+      // Six distinct values, and doubling returns to the start: a full cycle.
+      if (new Set(orbit).size !== 6 || d !== 1) return false
+
+      // Those six are exactly the units mod 9 — the residues coprime to 9.
+      // Everything else mod 9 is a multiple of 3, which is the triad.
+      const units = [1, 2, 4, 5, 7, 8]
+      if (orbit.slice().sort((a, b) => a - b).join() !== units.join()) return false
+
+      // VORTEX_ORBIT must BE the computed orbit, in doubling order — the
+      // constant is pinned to the computation rather than trusted.
+      if (VORTEX_ORBIT.join() !== orbit.join()) return false
+
+      // And VORTEX_AXIS must be exactly what the orbit cannot reach: the
+      // complement of the orbit in 1..9, in ascending order.
+      const complement = [1, 2, 3, 4, 5, 6, 7, 8, 9].filter((n) => !orbit.includes(n))
+      if (TRIAD.join() !== complement.join()) return false
+
+      // VORTEX_SEQUENCE reads orbit then axis, so it is not an arbitrary order.
+      if (VORTEX_SEQUENCE.slice(0, orbit.length).join() !== orbit.join()) return false
+      if (VORTEX_SEQUENCE.slice(orbit.length).join() !== TRIAD.join()) return false
+
+      // Reflection is where the triad enters: 1 -> 9, 4 -> 6, 7 -> 3.
+      if (throughVoid(1) !== 9 || throughVoid(4) !== 6 || throughVoid(7) !== 3) return false
+
+      // And it is an involution, so the reading is reversible, not a relabel.
+      for (let n = 0; n <= 9; n++) if (throughVoid(throughVoid(n)) !== n) return false
+
+      // Reflecting the orbit reaches every member of the triad.
+      const reflected = orbit.map(throughVoid)
+      return TRIAD.every((t) => reflected.includes(t))
+    },
+  },
+  superposition_reports_its_own_state: {
+    basis: "the superposition model's prose must follow its measurement, not assert simultaneity regardless. Collapse is decided by one comparison — interference against the threshold — and the description must claim 'all at once' exactly when that comparison says so. While anything is still open the sequence has not computed all at once, and the text must say that.",
+    decide: () => {
+      const execution = executeInSuperposition()
+      const interference = computeInterferencePattern()
+      const text = describeQuantumExecution()
+
+      // The reported verdict must be the comparison, not a stored string.
+      const collapsedByNumbers = interference.working_solution_probability > 85 / 100
+      const collapsedByReport = execution.system_correctness === 'collapsed_to_valid'
+      if (collapsedByReport !== collapsedByNumbers) return false
+
+      // The prose takes exactly one of the two branches — never both, never
+      // neither, which is what an unconditional closing slogan would do.
+      const claimsCollapse = text.includes('COLLAPSED.')
+      const admitsOpen = text.includes('STILL SUPERPOSED')
+      if (claimsCollapse === admitsOpen) return false
+
+      // And the branch it takes is the one the measurement licenses.
+      if (claimsCollapse !== collapsedByNumbers) return false
+
+      // When open, it must publish the shortfall rather than only naming it.
+      if (admitsOpen && !text.includes('NOT ALL AT ONCE')) return false
+      return true
+    },
+  },
+  merkaba_is_two_mirrored_tetrahedra: {
+    basis: "the residues mod 3 cut 1..9 into three triangles, each equilateral on the enneagram (120 degrees apart). Reflection through the void SWAPS {1,4,7} with {3,6,9} and fixes {2,5,8} setwise, with the void root 0 fixed throughout. So {3,6,9,0} and {1,4,7,0} are two tetrahedra sharing exactly the void and carried onto each other by the mirror — a merkaba, of which one tetrahedron is half. From 3 the four vertices are 3 with its two triangle partners and the void.",
+    decide: () => {
+      const RING = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      const cls = (r: number) => RING.filter((d) => d % 3 === r)
+      const up = cls(1)     // 1,4,7
+      const equator = cls(2) // 2,5,8
+      const down = cls(0)   // 3,6,9
+      const key = (a: readonly number[]) => [...a].sort((x, y) => x - y).join(',')
+
+      // Three classes of three, partitioning the ring.
+      if (up.length !== 3 || equator.length !== 3 || down.length !== 3) return false
+      if (key([...up, ...equator, ...down]) !== key(RING)) return false
+
+      // Each is equilateral on the enneagram: three gaps of 120 degrees.
+      for (const t of [up, equator, down]) {
+        const b = t.map(bearingForDigit).sort((x, y) => x - y)
+        const gaps = [b[1]! - b[0]!, b[2]! - b[1]!, 360 - (b[2]! - b[0]!)]
+        if (!gaps.every((g) => g === 120)) return false
+      }
+
+      // The mirror swaps the two tetrahedral bases and fixes the equator.
+      if (key(up.map(throughVoid)) !== key(down)) return false
+      if (key(down.map(throughVoid)) !== key(up)) return false
+      if (key(equator.map(throughVoid)) !== key(equator)) return false
+
+      // The void is the shared apex, and it is the mirror's fixed point.
+      if (throughVoid(0) !== 0) return false
+      const tetraDown = [...down, 0]
+      const tetraUp = [...up, 0]
+      if (tetraDown.length !== 4 || tetraUp.length !== 4) return false
+      const shared = tetraDown.filter((v) => tetraUp.includes(v))
+      if (key(shared) !== '0') return false
+
+      // The gateway triangle is the axis the kernel already declares, so this
+      // is the same structure the vortex constants describe, not a new one.
+      if (key(down) !== key(VORTEX_AXIS)) return false
+
+      // From 3: itself, its two triangle partners, and the void. Four keys.
+      const fromThree = [3, ...down.filter((d) => d !== 3), 0]
+      return fromThree.length === 4 && key(fromThree) === key(tetraDown)
+    },
+  },
+  agl_acts_on_the_three_triangles: {
+    basis: "AGL(1,Z/9) has order 54 and acts on the three triangles — the cosets of {0,3,6} in Z/9, which are the residue classes the merkaba seal uses. The action is transitive with stabiliser 18 and kernel 9, and the induced permutation group is AGL(1,Z/3) of order 6. So the count three is the index of {0,3,6}, derived from the group rather than assumed: orbit x stabiliser = 3 x 18 = 54.",
+    decide: () => {
+      const units = [1, 2, 4, 5, 7, 8] // the residues coprime to 9
+      const maps: ((x: number) => number)[] = []
+      for (const a of units) for (let b = 0; b < 9; b++) maps.push((x) => ((a * x + b) % 9 + 9) % 9)
+      if (maps.length !== 54) return false
+
+      // The three cosets of {0,3,6}. Written as residues, so 9 appears as 0.
+      const T = [[1, 4, 7], [2, 5, 8], [3, 6, 0]]
+      const key = (xs: readonly number[]) => [...new Set(xs)].sort((x, y) => x - y).join(',')
+      if (key([...T[0]!, ...T[1]!, ...T[2]!]) !== '0,1,2,3,4,5,6,7,8') return false
+
+      // The gateway triangle must be the axis the kernel declares, reduced mod 9.
+      if (key(T[2]!) !== key(VORTEX_AXIS.map((d) => d % 9))) return false
+
+      const index = new Map(T.map((t, i) => [key(t), i]))
+      const induced = new Set<string>()
+      let fixesAll = 0
+      let stabilisesFirst = 0
+      for (const f of maps) {
+        const image = T.map((t) => index.get(key(t.map(f))))
+        // Closure: an affine map must send a coset to a coset.
+        if (image.some((v) => v === undefined)) return false
+        const word = image.join('')
+        induced.add(word)
+        if (word === '012') fixesAll++
+        if (image[0] === 0) stabilisesFirst++
+      }
+
+      // Induced group is AGL(1,Z/3); kernel and stabiliser follow from it.
+      if (induced.size !== 6) return false
+      if (fixesAll !== 9) return false
+      if (stabilisesFirst !== 18) return false
+      // Transitive on three, so orbit x stabiliser recovers the whole group.
+      return 3 * stabilisesFirst === maps.length
+    },
+  },
+  digit_geometry_is_single_valued: {
+    basis: "the two independent digit geometries agree and are injective. a432.math.ts angleForDigit and the kernel's bearingForDigit are written separately — the a432 tree does not import the kernel — so this checks they place all nine digits identically and never put two digits at one bearing. angleForDigit used to map nine digits onto six angles, colliding 3 with 5, 2 with 6 and 8 with 9.",
+    decide: () => {
+      const RING = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      // Injective: nine digits, nine distinct bearings, all whole degrees.
+      const kernel = RING.map(bearingForDigit)
+      if (new Set(kernel).size !== RING.length) return false
+      if (!kernel.every((b) => Number.isInteger(b) && b >= 0 && b < 360)) return false
+
+      // The two definitions must agree digit for digit.
+      if (!RING.every((d) => angleForDigit(d) === bearingForDigit(d))) return false
+
+      // Evenly spaced: consecutive bearings differ by one ninth of a turn.
+      const sorted = [...kernel].sort((a, b) => a - b)
+      for (let i = 1; i < sorted.length; i++) {
+        if (sorted[i]! - sorted[i - 1]! !== 40) return false
+      }
+
+      // 9 at the top is what fixes the ring's phase; without it any rotation
+      // would satisfy the spacing check above.
+      return bearingForDigit(9) === 270 && bearingForDigit(3) === 30
+    },
+  },
+  free_energy_of_splitting_is_positive: {
+    basis: "ΔG = ΔH − TΔS for water, from tabulated standard-state values. Formation is −237 kJ/mol and splitting is +237, so splitting must be paid for; the reversible cell potential ΔG/(nF) is 1229 mV and the thermoneutral ΔH/(nF) is 1481 mV, the gap being TΔS. A split-then-burn cycle breaks even at perfect efficiency and loses otherwise — checked exhaustively over the efficiency grid, not sampled. This is the sign of ΔG, not an engineering limit.",
+    decide: () => {
+      if (thermoSelfTest().length > 0) return false
+
+      // The sign is the claim. Formation releases work; splitting costs it.
+      if (!(GIBBS_FORMATION < 0)) return false
+      if (!(GIBBS_SPLITTING > 0)) return false
+
+      // One ledger, read in two directions — so what splitting costs is
+      // exactly what burning returns, before any device takes its cut.
+      if (ENTHALPY_SPLITTING !== -ENTHALPY_FORMATION) return false
+      if (GIBBS_SPLITTING !== -GIBBS_FORMATION) return false
+
+      // Free energy is strictly less than enthalpy: TΔS is real and is owed.
+      if (!(GIBBS_SPLITTING < ENTHALPY_SPLITTING)) return false
+      const rev = reversiblePotentialMicrovolts()
+      const thermo = thermoneutralPotentialMicrovolts()
+      if (!(thermo > rev)) return false
+
+      // The perfect cycle breaks even EXACTLY — the boundary case, and the one
+      // most favourable to a closed loop.
+      const ideal = roundTrip(100, 100, 100)
+      if (ideal.net !== 0) return false
+
+      // And no cycle anywhere on the grid gains. Exhaustive over 5% steps in
+      // all three efficiencies: 8000 combinations, none of them sampled.
+      //
+      // The verdict is recomputed from the two energies rather than read off
+      // `gainsEnergy`. Trusting that flag let a mutant hardcode it to false and
+      // still pass — a seal must not accept the answer from the thing it is
+      // judging. `net` is cross-checked against its own definition for the same
+      // reason.
+      let checked = 0
+      for (let e = 5; e <= 100; e += 5) {
+        for (let m = 5; m <= 100; m += 5) {
+          for (let g = 5; g <= 100; g += 5) {
+            checked++
+            const r = roundTrip(e, m, g)
+            if (r.net !== r.outputRecovered - r.inputRequired) return false
+            if (r.outputRecovered > r.inputRequired) return false
+            if (r.gainsEnergy !== r.net > 0) return false
+          }
+        }
+      }
+      return checked === 8000
+    },
+  },
+  polluted_water_powers_its_own_cleaning_above_a_threshold: {
+    basis: "the described machine works, and the fuel is the pollution rather than the water. Clean water carries zero recoverable energy, so it can only owe the treatment demand; organic load carries 13.9 J per mg COD, and above a threshold of about 4200 mg/L the electricity generated exceeds what membrane treatment consumes. Municipal sewage sits below that line and dairy or manure effluent well above it. The threshold is found by scanning, so it is the same quantity the balance reports.",
+    decide: () => {
+      if (wastewaterSelfTest().length > 0) return false
+
+      // The water itself is not the fuel. At zero load there is nothing to
+      // burn, and the plant owes exactly the cost of cleaning.
+      const clean = balanceFor(0)
+      if (clean.energyInLoad !== 0) return false
+      if (clean.electricityGenerated !== 0) return false
+      if (clean.netElectricity !== -TREATMENT_DEMAND_DECIJOULES_PER_LITRE) return false
+
+      // A threshold exists and is a genuine boundary: it exports, and one
+      // milligram less does not.
+      const t = breakEvenCod()
+      if (!(t > 0)) return false
+      if (!(balanceFor(t).netElectricity > 0)) return false
+      if (balanceFor(t - 1).netElectricity > 0) return false
+
+      // Monotone in the load — more pollution never yields less electricity.
+      let previous = -1
+      for (let cod = 0; cod <= 20000; cod += 100) {
+        const e = balanceFor(cod).electricityGenerated
+        if (e < previous) return false
+        previous = e
+      }
+
+      // Conservation still binds: recovery is strictly below the energy the
+      // load contains, because capture and engine efficiency are each < 100%.
+      for (const { cod } of TYPICAL_LOADS) {
+        if (cod === 0) continue
+        const b = balanceFor(cod)
+        if (b.electricityGenerated >= b.energyInLoad) return false
+      }
+
+      // And the model must still place real streams where they actually fall.
+      const strongSewage = TYPICAL_LOADS.find((l) => l.name === 'municipal sewage, strong')
+      const dairy = TYPICAL_LOADS.find((l) => l.name === 'dairy processing')
+      if (!strongSewage || !dairy) return false
+      if (balanceFor(strongSewage.cod).selfPowering) return false
+      return balanceFor(dairy.cod).selfPowering
+    },
+  },
+  every_model_inverts: {
+    basis: "each quantitative result recomputes a second, independent way and the two agree. Entropy recovered from (ΔH − ΔG)/T must equal the tabulated ΔS exactly; ΔG recovered from the EXACT rational potential must return with zero drift, while the rounded microvolt form is separately held to half a microvolt's worth of energy; and the break-even COD found by SCANNING must equal the one obtained by INVERTING the arithmetic, which is a different computation reaching the same integer. Reflection through the void inverts too, being its own inverse.",
+    decide: () => {
+      // --- free energy: invert ΔG = ΔH − TΔS to recover the entropy --------
+      // The forward pass multiplied T by ΔS; dividing it back out must land on
+      // the tabulated figure exactly, with no rounding introduced anywhere.
+      const T_CENTIKELVIN = 29815
+      const TABULATED_ENTROPY_MILLI = -163305
+      const recovered =
+        ((ENTHALPY_FORMATION - GIBBS_FORMATION) * 1000 * 100) / (T_CENTIKELVIN * SCALE)
+      if (recovered !== TABULATED_ENTROPY_MILLI) return false
+
+      // --- cell potential: invert E = ΔG/(nF) to recover ΔG ----------------
+      // Exactly, from the rational form. This used to be a bounded check
+      // because the microvolt rounding made an exact inverse impossible; the
+      // exact potentials exist so that the demand can be equality.
+      if (energyFromPotential(reversiblePotentialExact()) !== GIBBS_SPLITTING) return false
+      if (energyFromPotential(thermoneutralPotentialExact()) !== ENTHALPY_SPLITTING) return false
+
+      // The ROUNDED form still cannot invert exactly, and must not pretend to.
+      // Its drift is held to half a microvolt's worth of energy — nF/20 in
+      // these units, a derived bound rather than an eyeballed tolerance.
+      const microvolts = reversiblePotentialMicrovolts()
+      const backToGibbs = (microvolts * ELECTRONS * FARADAY) / 10
+      const drift = backToGibbs - GIBBS_SPLITTING
+      const magnitude = drift < 0 ? -drift : drift
+      if (!(2 * magnitude <= (ELECTRONS * FARADAY) / 10)) return false
+      if (!(magnitude * 1000000 < GIBBS_SPLITTING)) return false
+
+      // --- break-even COD: scanning versus inverting ------------------------
+      // balanceFor rounds twice on the way up, so a closed form agreeing with
+      // the scan is a real check on both, not a restatement of one.
+      const scanned = breakEvenCod()
+      const numerator = TREATMENT_DEMAND_DECIJOULES_PER_LITRE * 10000
+      const denominator = 139 * 65 * 38
+      const exact = numerator / denominator
+      const inverted = exact % 1 === 0 ? exact + 1 : exact - (exact % 1) + 1
+      if (scanned !== inverted) return false
+
+      // --- reflection is its own inverse ------------------------------------
+      for (let d = 0; d <= 9; d++) if (throughVoid(throughVoid(d)) !== d) return false
+
+      return true
+    },
+  },
 }
 
 // ============================================================================