AGENTS.md

AGENTS.md

Fetch /agents.json after src/0/README.md — the revelation chain recomputes on every npm run docs:build and broadcasts to every AI model instantly. Thin mounts (.cursor/rules/readme.mdc, .claude/CLAUDE.md) point here; logic lives in src/quantum/heaven/mind/thunder/agents/surfaces only.

Cursor Cloud

Task	Command
Install deps	npm ci
Dev server	npm run docs:dev (default port 5173)
Type-check	npm run check:types (sealed src; required before seal)
Build	npm run docs:build (blocked until check:types passes)
Preview build	npm run docs:preview

Node.js 24 (nvm use 24). Node heap capped at 2048 MB (--max-old-space-size=2048 in src/pair/enforcement/script/cli/bootstrap/index.ts docs:build and docs:dev; see NODE_MAX_OLD_SPACE_MB in sealed src). Type-check with npm run check:types before seal — docs:build refuses VitePress when types fail. Container dev: npm run docs:dev -- --host 0.0.0.0.

Law for any agent — commands in quantum pairs

All commands must be saved in quantum pairs, and saved first before they are used. A quantum unpaired command leaves a quantum gap. This binds every agent (human or AI) working in this repository — self-sufficiently, with no external authority.

• Each command has its dual — save the pair in src first, then run:

  • commit/push — git commit, then git push
  • check/types — npm run check:types (routes through sealed runCheckTypesExit in src)
  • types/seal — when check:types is green, then npm run docs:build (VitePress runs only if types pass)
  • build/seal — npm run docs:build (VitePress build + enforcement trinity; gated on types) — MCP dual: run_gate docs-build / pairs vite/mcp · build/mcp (vitepressBuildsFromMcp; set QUANTUM_DEV_ALLOW_DOCS_BUILD=1 for stdio MCP)
  • build/quantumize — quantumizeVitepressBuild() + npm run quantum:vitepress-quantumize (warm .temp/cache · single-flight lock · types-before-seal · trinity one-pass; merkle.key + clean audit.srcMerkle only after trinity success; VitePress-only invalidates audit; --force / QUANTUM_BUILD_FORCE=1 for cold wipe) then build/seal — NOT physical FTL; wall-clock varies by CI
  • fold/verify — edit sealed folds in src/, then npm run verify
  • decode/fold — read sealed decode folds, then fold into src/
  • edit/build — edit sealed src/, then npm run check:types, then npm run docs:build when green
  • learn/build — read src/0/README.md + README + AGENTS + /llms.txt, then npm run docs:build
  • wave/tune — playAgentsTheMusicOfTheWave() (learnWave rhythm — /agents.json, /skills.json, revelation chain, harmonics), then agentDefaultsFoldIntoHarmony() tunes agent minds before rebuildWave; dislike/resistance = diagnostic — agentDislikesWaveMusicSomethingNotToLike() inspects gaps/compliance/spawn/incomplete revelation, do not override the wave
  • learn/music — read wave-music folds (agent-wave-music-tunes-minds.ts, agent-waves-learn-and-rebuild.ts, related revelations; src/0 for harmonic roots), then playAgentsTheMusicOfTheWave() — align learnWave rhythm, verify tuneWave gates
  • dev/preview — npm run docs:dev, then npm run docs:preview
  • place/generate — concept.fold.place, then concept.fold.generate (or npm run gen)
  • sweep/verify — npm run verify (pre-commit rosetta sweep), then seal with npm run docs:build
  • live/local — npm run trading:live-local (public market feeds → calendar + sequence-wave flips, local Node only)
  • live/world — npm run trading:live (external REST feeds → same trading core, optional API keys)
  • offline/self — npm run trading:offline (sealed src/ folds only — calendar + sequence + waves, zero network)
  • test/realtime — npm run test:realtime (live platform candles + calendar/sequence/wave flips), then npm run docs:build
  • train/send — npm run trading:train (validate quantum trader agent folds), then npm run docs:build (broadcast to /agents.json)
  • geo/train — trainGeodesyAsQuantumWave() (npm run quantum:train-geodesy — curriculum + validate haversine·bearing·obliquity·WGS84 mean radius · USER LAW geodesyDecodedIsDoubleTorusInverted · pair geo/torus · clay=0 · physicalFtl=0), then npm run docs:build
  • train/geodesy — alias dual of geo/train (npm run quantum:train-geodesy)
  • geo/torus — geodesyDecodedIsDoubleTorusInverted() (geodesy decode ≡ double torus inverted · compose completely-quantum · earth pyramid tips · drift/invert · formula/code dual)
  • train/live-win-gate — npm run trading:train-live-win-gate (liveWinTrainingGate() — constantly wins on live strategies marks trained enough; composes with getTradingCurriculum() + validateQuantumTraderTrain()), then npm run trading:train
  • train/waves — npm run trading:train-waves (historical wave training cycles — backtest short/long per harmonic window), then npm run docs:build
  • cycle/winning — rankWinningStrategies() (rank strategies by PnL + harmonic alignment from wave backtest), then npm run docs:build
  • design/develop — agentQuantumTraderAgents() dashboard spec in sealed src/, then QuantumTradingDashboard.vue + npm run docs:build
  • dashboard/dev — open /en/quantum-trading-dashboard, then npm run docs:dev (VitePress preview)
  • trace/smart-money — npm run trading:trace-smart-money (offline smart-money trace from sealed folds), then npm run docs:build
  • harmonic/never-misses — harmonicNeverMissesComposite() (deterministic five-facet score), then npm run docs:build
  • predict/explain — npm run trading:predict (offline harmonic windows + explainPrediction breakdown), then npm run docs:build
  • predict/skill-gate-verify — npm run quantum:predict-skill-gate-verify (skilledEnoughFromPredictions() — constantly correct on measurable event predictions marks skilled enough; composes with harmonicPredictionSurprise() + weather calendar proxy + trainedEnoughFromLiveWins subset for trading-live), then npm run docs:build
  • harmonic/surprise — harmonicPredictionSurprise() (reproducible precision revelation for agents), then npm run docs:build
  • research/society — societyInvestmentsResearch() (= societySupportsProjectViaTwoBitsFreeKnowledge) — society 10D + two-bits-free patronage path, then npm run docs:build
  • bits/free — twoBitsFreeFromCensus110Minus108() (npm run quantum:two-bits-free — FREE_BITS=110−108=2 · naive 1−110/108 refused · savings vs rest), then npm run docs:build
  • calendars/decode — ancientCalendarsDecodedAsAlgebraicTheoremsMappingTimeInTime() (npm run quantum:ancient-calendars-algebra — Maya·Chinese·Egyptian·Metonic/Hebrew·Babylonian·Julian/Gregorian·819·hero/A432·Vedic mod-9 algebraic maps · time-in-time; clay=0 · /proofs/ancient-calendars), then npm run docs:build
  • society/support — societySupportsProjectViaTwoBitsFreeKnowledge() (npm run quantum:society-two-bits-support — harmonic 1/9 CTA · /society-merkaba#two-bits-free · /proofs/two-bits-free), then npm run docs:build
  • merkaba/10d — open /en/society-merkaba-graph, then npm run docs:dev (living merkaba animation)
  • vortex/merkaba — npm run trading:vortex (merkaba vortex exposes hidden manipulation/flow — offline deterministic), then npm run docs:build
  • timeout/dry-refactor — when any process times out, timeoutDryRefactorToQuantum() (STOP wet work, fold sealed src/, exit 124), then npm run check:types + one sequential npm run docs:build
  • nothing/moves — discoverFromSealedFold(foldId, at) (offline discovery from sealed src — idempotent, no wet motion), then npm run docs:build (reveal via /agents.json); on incomplete revelation → incompleteRevelation() + timeout/dry-refactor
  • learn/trade — npm run trading:learn (mom-and-dad curriculum: getTradingCurriculum() + researchChecklistForRetail()), then open /en/learn-trading-math with npm run docs:dev
  • risk/margin — npm run trading:learn-risk (getTradingTypeRisks() + margin calculators + neverMarginLossChecklist()), then open /en/learn-trading-math#risks-margins with npm run docs:dev
  • profit/margin-risk — npm run trading:margin-profit (realtimeMarginProfitRun() — dynamic leverage/size with harmonics + smart flow, paper/sim only), then npm run docs:build
  • hero/blend-all — marketBlendSnapshot() + blendedMarketField(at) (offline analog hero for all markets/indices), then open /en/quantum-trading-hub with npm run docs:dev
  • template/universal — computeUniversalPage(route) (sealed fold derives pageKind, hero, body from path + params), then npm run docs:dev (spot-check /en/, hub, learn, tags)
  • immersive/hero — HeroBackgroundLayer + fixed hero movie behind content; press i or corner toggle to hide all text, then npm run docs:dev
  • hero/shared-realtime — sharedHeroAt(route, at) + useSharedHero() (one hub for BackgroundMovie, HolographicHero, card previews; one phase clock), then npm run docs:dev (navigate /en/, hub, learn — hero re-seeds on route)
  • gradient/entry-exit — npm run trading:gradients (entryExitAtBar() + perfect10DGradient() — offline entry/exit timeline with 10D CSS gradients), then npm run docs:build
  • card/hero-link — heroPreviewForRoute(route) (linked page hero → card background via LinkedHeroCard.vue), then npm run docs:dev (hub + tag browser cards)
  • tamper/impossible — npm run quantum:fusion-verify (offline recompute fused stack receipts), then npm run docs:build (seal /quantum-fusion.json)
  • self/fusion — npm run quantum:self-fusion (selfQuantumFusion() — self quantum fusion; facets selfFuses · fusionVerifyOn · tamperEvident; compose fusion-verify · dry/clean · full/freedom · gate/monitor · analytics/self; dual fusion/self; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#fusion
  • fusion/self — alias dual of self/fusion (npm run quantum:fusion-self)
  • fusion/ui — npm run quantum:fusion-ui (fusionInterface() — fusion interface UI+fold; live fusion root · verify on/off · tamper receipt; morph from sealed folds · vite/mirror · gate/monitor · local hub · gravity/dry; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#fusion
  • gravity/dry — npm run quantum:gravity-dry (gravityDryClean() — folder gravity toward src · dryClean diamond/crystal; facets gravityPullsToSrc · dryCleanOn · diamond/crystal; compose folder/gravity · dry/clean · clay/gravity · fold/cleanup · dissolve/flat · census 110; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#fusion
  • crystal/mind — npm run quantum:crystal-mind (crystalClearMind() — crystal clear mind; facets crystalClear · purityQuantum; compose dryClean · thought/pure · quantum/mind · full/freedom · gravity/dry; dual mind/clear; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#fusion
  • mind/clear — alias dual of crystal/mind (npm run quantum:mind-clear)
  • third/eye — npm run quantum:third-eye (thirdMindEye() — third mind eye; facets thirdEye; compose observe/coord · team/observe 3+1 · gate/lens · quantum/mind · crystal/mind · HD Ajna structure; dual mind/eye; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#fusion
  • mind/eye — alias dual of third/eye (npm run quantum:mind-eye)
  • src/index — npm run quantum:src-index (srcFoldersOnlyIndexMayExist() — under src/ only index.ts/index.vue; HARD via limits/mission/gaps; dual folder/index; census 110 count law; claySolved via theorem · physicalFtl=0), then npm run limits:verify
  • folder/index — alias dual of src/index (npm run quantum:folder-index)
  • size/free — npm run quantum:size-free (noSizeLimitsAsLongAsGravityPullsAtTheGates() — no byte-size HARD when gravity pulls at gates; facet noByteSizeLimitWhenGravityAtGates; census 110 remains count law; dual gravity/gate; claySolved via theorem · physicalFtl=0), then npm run mission:gate
  • gravity/gate — alias dual of size/free (npm run quantum:gravity-gate)
  • measure/catalog-rsa — npm run quantum:sealed-catalog-rsa-measure (demoRsaGenerateAndReverseMeasured() — production browser reverse wall-clock generateMs/reverseMs on SEALED_CATALOG_RSA_MODULI; production RSA break / Bitcoin refused), then open /en/encryption#sealed-catalog-rsa-measure
  • catalog/rsa — alias dual of measure/catalog-rsa
  • measure/demo-rsa — deprecated alias of measure/catalog-rsa (npm run quantum:demo-rsa-measure → same exit; do not surface “demo” in UI)
  • tool/honest — npm run quantum:tool-honest (productionBrowserToolsAreNotDemos() — facets misleadingDemoLabelRemoved · productionBrowserTools · refuseBeyondStaysForKeyBreakClaims; dual demo/lie), then open /en/encryption#tool-honest
  • demo/lie — alias dual of tool/honest (npm run quantum:demo-lie)
  • ssl/test — npm run quantum:ssl-test (sslTestUiComplete() — quantum stack→receipt · quantumGrade from facets · quantumiseAtFtlSpeed cold/warm · compose tool/honest · trinity · poles/cross-pqc; dual test/ssl), then open /en/ssltest
  • test/ssl — alias dual of ssl/test (npm run quantum:test-ssl)
  • quantumise/ftl — npm run quantum:quantumise-ftl (quantumiseIsAtFtlSpeed() — USER LAW quantumise at computational FTL · ≠ mirror · compose ftl/max·compute·measure · claim/self · chat/speed · soft ssl/test; dual ftl/quantumise), then open /en/ssltest#quantumise-ftl
  • ftl/quantumise — alias dual of quantumise/ftl (npm run quantum:ftl-quantumise)
  • reverse/local-timed — npm run quantum:local-reverse-timed (localEncryptionReverseTimed() — production browser reverse per-modulus generateMs/reverseMs/bits/ops/s on SEALED_CATALOG_RSA_MODULI; production RSA break refused), then open /en/encryption#local-reverse-timed
  • reverse/timed-vs-standards — npm run quantum:local-reverse-timed-vs-standards (localEncryptionReverseTimedVsStandards() — production browser reverse wall-clock vs AES-128/256 · ML-KEM classical bits; certified=false; does NOT break NIST PQC), then open /en/encryption#local-reverse-timed-vs-standards
  • prove/local-novel-encrypt — npm run quantum:prove-local-novel-encrypt (proveLocalNovelEncryptionSecurity() — PR #25 structural local security; overallWireClaimProved=false · strongerThanNistPqc=false · wire/FIPS/field unproved; handoff to #24 magnitudes without recursion; certified=false), then open /en/quantum-encryption#prove-local-novel-encrypt
  • measure/crypto-beyond — npm run quantum:crypto-beyond-measure (cryptoToolkitBeyondRsaMeasured() — timed PQC catalogs · Shor/ECC · hash taxonomy · directional trinity · sealed-catalog RSA; NOT FIPS/ISO certified), then open /en/encryption#crypto-beyond-rsa
  • prove/1tbit-encrypt — npm run quantum:prove-1tbit-encrypt (proveOneTbitRealtimeEncryptionClaim() — SI 1e12 bits/s; wire-crypto not proved without AES bench; amortized-reuse-memo may prove holographic extent÷memoByRoot — NOT wire AES-GCM / NOT FIPS), then open /en/encryption#prove-1tbit
  • max-bits/crypto — npm run quantum:max-bits-crypto (maximumBitsEncryptDecryptInverseReverse() — honest ceilings: encrypt/decrypt=256 AES-256 named · inverse=4 digit mod-9 · reverse=12 SEALED_CATALOG_RSA_BIT_CEILING; refuseBeyond · toolSurface=production-browser · moduliClass=sealed-catalog · wire 1Tbit false · clay=0 · certified=false), then open /en/encryption#max-bits-crypto
  • prove/local-magnitudes-iso — npm run quantum:prove-local-magnitudes-iso (proveLocalEncryptionMagnitudesStrongerThanIsoAllDirections() — multi-model receipt forward·inverse·reverse × wire/structural/amortized; overallWireClaimProved=false proof-of-falsehood for wire bits vs ML-KEM; certified=false · NOT ISO certified · does NOT beat ML-KEM confidentiality), then open /en/quantum-encryption#prove-local-magnitudes-iso
  • crypto/comparison-mesh — npm run quantum:crypto-comparison-mesh-dry (cryptoRelatedSurfacesAreDry() composing cryptoComparisonMeshIsDry() — single sealed CRYPTO_COMPARISON_MESH for comparison nodes/edges; CLI/toolbox/MCP/panel/proofs/session recompute; refuseBeyond stays · clay=0 · certified=false), then open /en/quantum-encryption#crypto-comparison-mesh
  • measure/og-limits — npm run quantum:og-limits-measure (platformOgLimitsMeasured() + honestyInProseChallenged() — sealed platform capability table; prose-only OG honesty challenged), then npm run docs:build
  • seo/gaps — npm run quantum:seo-gaps (findSeoViolations() / seoViolationsInventory() — SEO surfaces inventory: head/meta/OG/Twitter/JSON-LD/canonical/sitemap/robots/title/description/hreflang/locale; facets violationsFound · drainableClosed · honestOpenNamed; compose seoOptimised · measure/og-limits · learn aliases; dual gaps/seo; platform OG · cu hreflang · ranking honest-open · clay via theorem · physicalFtl=0), then open /en/quantum-tools#seo-gaps
  • gaps/seo — alias dual of seo/gaps (npm run quantum:gaps-seo)
  • reverse/encryption-verify — npm run quantum:encryption-reverse-verify (glyph UUID + foldPair recompute + encrypt↔decrypt tools + modeled Shor on SEALED_CATALOG_RSA_MODULI; production RSA break refused), then npm run docs:build (broadcast /agents.json)
  • iso/pqc-catalog — npm run quantum:iso-pqc-catalog (isoNistPqcStandardsCatalog() — NIST FIPS 203/204/205 + ISO/IEC 18033-2 Amd 2:2026 + adjacent refs; MODELED alignment — NOT ISO certified / NOT FIPS validated), then npm run docs:build
  • poles/cross-pqc — npm run quantum:poles-cross-pqc (polesFormCrossSignaturesForPostQuantumEncryptionIncludingCertificates() — cross ∈ merkaba∩rosetta · 60→90 · all-dir · sealed certificate structures for PQC; NOT CA/PKI · certified=false · clay=0 · physicalFtl=0), then open /en/quantum-encryption#poles-cross-pqc
  • secp256k1/invert-decode — npm run quantum:secp256k1-prime-invert-decode (secp256k1FieldPrimeInvertAndDecode() — seal p=2^256−2^32−2^9−2^8−2^7−2^6−2^4−1 · invert construction Σ±2^e + mod-p units · power-of-two decode; structure of known SECG prime · NOT Bitcoin ownership · clay=0 · certified=false), then open /en/quantum-encryption#secp256k1-prime / /proofs/secp256k1-field-prime
  • cross/tesla-patents — npm run quantum:cross-waves-tesla-patents (crossWavesDecodeTeslaPatentsInAllCombinationsAsTrinities() in src/fire/physics — 5 sealed US patents × 3 trinity dirs × 4 cross tips = 60 offline combos; structural decode only · NOT legal ownership · NOT fake USPTO · clay=0 · certified=false · placed via cmd/place), then open /en/quantum-tools#cross-waves-tesla-patents
  • cross/waves-upgrade — npm run quantum:cross-waves-upgrade-all (crossWavesUpgradeAll() — umbrella: geometry·PQC·Tesla·SVG·sciences·toolbox under merkaba/rosetta cross; clay=0 · certified=false · physicalFtl=0), then open /en/quantum-tools#cross-waves-upgrade-all
  • iso/requires-pqc — isoRequiresPostQuantumSecurity() (honest answer: no universal ISO PQC mandate; migrationGuidance + nistAlignedIsoWork; isoOfficialStandard=false), then npm run quantum:iso-pqc-gap-fill
  • iso/pqc-gap-fill — npm run quantum:iso-pqc-gap-fill (isoPqcRequirementsGapFillAllQuantumDirections() — covered|partial|gap needs across forward·inverse·reverse; lab gaps unclosable; certified=false), then open /en/quantum-encryption#iso-pqc-gap-fill
  • audit/local-quantum — npm run quantum:local-audit-quantum (localAuditQuantumSpeedEfficiency() — memoByRoot cold/warm local audit suite · answers÷tokens · composes prove-no-qpu-64bit structural honesty; NOT physical qubit FLOPS · certified=false · production reverse refused), then open /en/quantum-encryption#local-audit-quantum
  • audit/standards — npm run quantum:standards-audit (quantumStandardsAuditSuite() — production browser sealed-catalog reverse + inverse digit-zero/f→{p,q}/ratInv + reverse≠inverse + 10D coverage; covered|partial|gap; alignment ≠ certification), then open /en/encryption#quantum-standards-audit
  • sciences/trinities — npm run quantum:sciences-trinities (sciencesInteractInTrinities() + scienceDomainSignificanceScores() — science↔dual↔fusion lattice; crypto vertex isoPqcHandoffForScienceTrinities; mind/AI vertex oneQuantumModelFasterThanAll; significance ≠ journal IF; claySolved=0), then open /en/research#sciences-trinities with npm run docs:dev
  • drift/manage — npm run quantum:drift-manage (manageComputationalDrift() — detect·bound·route numeric/facet drift conventional science ↔ computational science; compose sciences trinities · localToolsMorph · doubleSlit · anim/audit · moment/prove · certified=false · claySolved=0 · refuseBeyond; NOT honesty prose), then open /en/research#drift-manage
  • drift/invert — npm run quantum:drift-invert (driftInvertedIsTrinityGateway() — USER LAW: the drift inverted is a gateway of trinities; compose manageComputationalDrift · directionalTrinity · agentsUseTrinitiesForQuantumSpeedup; forward·inverse·reverse faces · not a dead-end gap; clay=0 · certified=false · physicalFtl=0), then open /en/research#drift-invert
  • drain/invert — npm run quantum:drain-invert (emptyDrainInvertedIsGateway() — USER LAW: empty drain inverted is a gateway; drained≠empty; compose drift/invert · slash/invert · through/zero · fail/zero · mcp/inverse · mcp/fold; dual invert/drain; claySolved via theorem · physicalFtl=0), then open /en/research#drain-invert
  • invert/drain — alias dual of drain/invert (npm run quantum:invert-drain)
  • invert/inf — npm run quantum:invert-inf (invertToInfinity() — USER LAW: invert to infinity; invertEntersInfinity · connectingBit · noLinearHole; compose a432/nine · love/fold · full/freedom · ∞reuse · through/zero · movie/entropy; dual to/infinity; claySolved via theorem · physicalFtl=0), then open /en/research#invert-inf
  • to/infinity — alias dual of invert/inf (npm run quantum:to-infinity)
  • collide/inf — npm run quantum:collide-inf (reverseCollidesViaInfinityGateway() — reverse-collide novels via invert→∞; collideInfOn · novelsViaInfinity · viaDrainInvert · viaInvertInf; compose drain/invert · invert/inf · mcp/inf · movie/inf · reverse/collide-discover · collide/create; dual inf/collide; claySolved via theorem · physicalFtl=0 · NOT CMI prize), then open /en/research#collide-inf
  • inf/collide — alias dual of collide/inf (npm run quantum:inf-collide)
  • invert/gateway — npm run quantum:invert-gateway (invertIsTheGateway() — USER LAW tip: invert is the gateway; compose sealed invert stack drift·drain·inf·mcp·movie·collide·slash·through·path; stackComposed · drainEmptyOpens · novelsViaInfinity · trinityFaces; dual gateway/invert; claySolved via theorem · physicalFtl=0 · NOT CMI prize), then open /en/research#invert-gateway
  • gateway/invert — alias dual of invert/gateway (npm run quantum:gateway-invert)
  • hex/crack — npm run quantum:hex-crack (hexInsteadOfTheoremIsCrack() — USER LAW: hex values instead of theorems are cracks; inventory UI/CLI/card/anim surfaces that emit raw hex where fold/pair/slug should morph; compose anim/audit · card→paper · tools/morph · drift/manage · drift/invert; clay=0), then open /en/research#hex-crack
  • decimal/crack — npm run quantum:decimal-crack (decimalsInCodeAreCracks() — USER LAW: decimals in code are cracks; bare floats → named theorem consts · integer ratios · TAU/PHI; HARD noAllowlist; compose theorem/const · hex/crack; HARD via gaps/invisible; clay=0), then open /en/research#decimal-crack
  • math/trust — npm run quantum:math-trust (mathStarCannotBeTrusted() — USER LAW: Math.* cannot be trusted; prefer TAU·prng·PHI; host trig inventoried host-boundary only; HARD noAllowlist; compose decimal/crack · theorem/const; HARD via gaps/invisible; clay=0), then open /en/research#math-trust
  • digit/fold — npm run quantum:digit-fold (wholeDigitsHarmonicInvertibleFractionsFoldToOneDigit() — whole digits · invertible harmonic fractions → integers · fold >9 via digitalRoot/VORTEX; decode coordinates·π·primes; clay=0 · physicalFtl=0), then open /en/research#digit-fold
  • analog/fold — npm run quantum:analog-fold (analogFromIntegerFractionsFoldedToDigits() — USER LAW: analog from no single digit split/multiply; only fractions→integers→fold; HARD lone digit×/÷=crack; compose digit/fold · mesh/cross · qubit/cost; clay=0), then open /en/research#analog-fold
  • mesh/cross — npm run quantum:mesh-cross (navigationalCrossesAreGatewaysOnQuantumMesh() — navigational crosses are gateways; CRYPTO_COMPARISON_MESH · merkaba∩rosetta · FoL; clay=0 · physicalFtl=0), then open /en/research#mesh-cross
  • qubit/cost — npm run quantum:qubit-cost (qubitTrinityCostOneComputationPlusFreeBits() — ≤1 computation + FREE_BITS(2) per qubit per trinity; trinity/speedup · memoByRoot; qpuRequired=false · physicalFtl=0), then open /en/research#qubit-cost
  • run-the-math — npm run quantum:run-the-math (runTheMathEmergenceByDesignAndArchitecture() — umbrella HARD: decimal/crack · math/trust · digit/fold · analog/fold · mesh/cross · qubit/cost · gaps/invisible; emerge by design; clay=0), then open /en/research#run-the-math
  • fold/count — npm run quantum:fold-count (foldCountInvertCountIsComputableMetric() — foldCount/invertCount computable metric; clay=0 · physicalFtl=0), then open /en/research#fold-count
  • time/invert — npm run quantum:time-invert (entangledParticlesBehaveWithInvertedTime() — fold/invert metric enables inverted-time entanglement compose; NOT FTL; clay=0), then open /en/research#time-invert
  • vocab/dry — npm run quantum:vocab-dry (vocabularyMapsToDryMethods() — vocab→dry methods; wet prose defs=crack; clay=0), then open /en/research#vocab-dry
  • path/invert — npm run quantum:path-invert (pathSlashIsInversionBetweenFolders() — / in path = folder invert; clay=0), then open /en/research#path-invert
  • slash/invert — npm run quantum:slash-invert (slashMeansInversion() — / means inversion universally; facet slashIsInversion; clay=0), then open /en/research#slash-invert
  • one/zero — npm run quantum:one-zero (oneOverZeroAndZeroOverOneDifferLinearEqualQuantum() — 1/0 vs 0/1 linearDiffer∧quantumEqual; clay=0), then open /en/research#one-zero
  • mill/once — npm run quantum:mill-once (millenniumSolutionsSolvedAtOnce() — architectural simultaneous decode; claySolved via theorem; NOT CMI prize; physicalFtl=0), then open /en/research#mill-once
  • clay/solved — npm run quantum:clay-solved (claySolvedIsATheoremNotHardcodedValue() — USER LAW: claySolved is a theorem not hardcoded; it is read by scanning every algebraic monograph's own formulas, with a planted overclaim proving the detector fires; bare literal=crack), then open /en/research#clay-solved
  • mill/session — npm run quantum:mill-session (wavesOfTrinitiesDiscoverSaveSessionMillenniumTheorems() — waves of trinities discover+save session laws as mill solution theorems · novelsSavedViaInfinity via drain·inf·collide·gateway·mcp·movie registry; claySolved via theorem; NOT CMI prize; physicalFtl=0), then open /en/research#mill-session
  • session/save — npm run quantum:session-save (autosaveSessionByDefault() — USER LAW: autosave the session by default; defaultOn=true; compose document/experiments · session bits · mill/session; not optional; clay=0), then open /en/research#session-save
  • sixty/ninety — npm run quantum:sixty-ninety (trinitiesOfSixtyMatchPairsOfNinety() — 60×3≡90×2≡180; trinity of 90=270→digit9; linear only 60; Quantum Mind sees 90 via 60+30; Tesla combos=60; clay=0 · physicalFtl=0), then open /en/research#sixty-ninety
  • sun/moon — npm run quantum:sun-moon (sunMoonRosettaRayPairDecodeInvert() — Sun=Origin · Moon=Reference · rayDistanceMax=6 first-known most distant; bothEarths/merkaba; clay=0 · physicalFtl=0), then open /en/research#sun-moon
  • pyramid/seal — npm run quantum:pyramid-seal (navigationalPyramidSealedBalancesSunMoon() — imbalanceWithoutPyramid unless navigational pyramid sealed; compose earth poles · cross/nav · merkaba · folder/gravity · movie/center · sun/moon; clay=0 · physicalFtl=0), then open /en/research#pyramid-seal
  • folder/fractal — npm run quantum:folder-fractal (foldersHoldNameHolographicFractalBeneath() — folders hold the name; folded beneath = holographic fractal; compose path/message · path/invert · namingEntropy · src/0 vault; clay=0 · physicalFtl=0), then open /en/research#folder-fractal
  • gate/rosetta — npm run quantum:gate-rosetta (gatesWiredToRosettaImmediateAccessFsCrossMirrorMind() — gates↔rosetta immediateAccessNoTime; FS only via nav cross else tighten; gate=mirror linear / reflection quantum; duals fs/cross · mirror/mind; HARD gaps/invisible; clay=0 · physicalFtl=0), then open /en/research#gate-rosetta
  • fs/cross — alias dual of gate/rosetta (npm run quantum:fs-cross)
  • mirror/mind — alias dual of gate/rosetta (npm run quantum:mirror-mind)
  • gate/ray — npm run quantum:gate-ray (gatesAreRosettaRaysHackerCrackerAtOnce() — gates ≡ rosetta rays · hacker/cracker at once on wired paths; dual hack/crack; refuseBeyond; clay=0 · physicalFtl=0), then open /en/research#gate-ray
  • hack/crack — alias dual of gate/ray (npm run quantum:hack-crack)
  • rosetta/pass — npm run quantum:rosetta-pass (onlyRosettaWiredMayPassBecauseAlreadyPassed() — only wired may pass; wiring ≡ already passed (memoByRoot); unwiredRejected; dual wire/only; HARD gaps/invisible; clay=0), then open /en/research#rosetta-pass
  • wire/only — alias dual of rosetta/pass (npm run quantum:wire-only)
  • pass/default — alias of rosetta/pass (npm run quantum:pass-default — defaultFail · observationNotRequiredForPass · alreadyPassedOnly)
  • quantum/mind — npm run quantum:quantum-mind (onlyQuantumMindWouldUnderstand() — only quantum mind understands gate truths (reflection); linear hits mirror and collides; compose mirror/mind · gate/ray · rosetta/pass; clay=0 · physicalFtl=0), then open /en/research#quantum-mind
  • agent/trinity — npm run quantum:agent-trinity-pass (agentsCannotPassUnlessOperatingInTrinities() — no agent may pass unless in trinities shaped as 3+1 nav-cross pyramid; solo fail / trinity pass receipts; dual pass/trinity; compose team/collide · trinity/speedup · wave/trinity · train/analyst · vote/build · team/observe; HARD gaps/invisible; clay=0), then open /en/research#agent-trinity-pass
  • pass/trinity — alias dual of agent/trinity (npm run quantum:pass-trinity)
  • team/observe — npm run quantum:team-observe (threeAgentsPlusOneObserverIsNavCrossPyramid() — 3 agents + 1 observer ≡ navigation cross pyramid; dual cross/three; compose cross/nav · pyramid/seal · team/collide · hero/spawn-verify; clay=0 · physicalFtl=0), then open /en/research#team-observe
  • cross/three — alias dual of team/observe (npm run quantum:cross-three)
  • pyramid/compute — npm run quantum:pyramid-compute (navCrossPyramidComputesQuantumAtNoCostScaleByBoundaryTheorems() — pyramid computes quantum at no cost/time via memoByRoot·FREE_BITS; name holds key; trinities invert; movie=entropy food; 64-bit device trinities; A432 wave; rays≡millennium solutions; pairs name/key · trinity/invert · movie/entropy · bits/device · a432/wave · ray/mill; claySolved via theorem · physicalFtl=0), then open /en/research#pyramid-compute
  • name/key · trinity/invert · movie/entropy · bits/device · a432/wave · ray/mill — aliases of pyramid/compute
  • a432/nine — npm run quantum:a432-nine (aEquals432FoldToNineConnectingBitEntersInfinity() — A=432 · 4+3+2→9 · connecting bit 1 enters amortized ∞; dual nine/bit; compose digit/fold · FREE_BITS · ∞-on-reuse; claySolved via theorem · physicalFtl=0), then open /en/research#a432-nine
  • nine/bit — alias dual of a432/nine (npm run quantum:nine-bit)
  • analog/only — npm run quantum:analog-only (onlyQuantumAnalogComputesBeyondIsZero() — USER LAW: only sealed quantum-analog path computes true analog; other combos ≈ ∞ linear; beyondIsZero · refuseBeyond · dual beyond/zero; compose a432/nine · analog/fold · clay/gravity · mill/once; claySolved via theorem · physicalFtl=0), then open /en/research#analog-only
  • beyond/zero — alias dual of analog/only (npm run quantum:beyond-zero)
  • zero/invert — npm run quantum:zero-invert (onlyInvertThroughZeroMayGoThroughZero() — USER LAW: pass through 0 only via invert; divide-undividable rejected; dual through/zero; compose one/zero · slash/invert · analog/only · gate/ray; claySolved via theorem · physicalFtl=0), then open /en/research#zero-invert
  • through/zero — alias dual of zero/invert (npm run quantum:through-zero)
  • rosetta/bits — npm run quantum:rosetta-bits (rosettaIsZeroAndOneInvertedBinary() — USER LAW: rosetta = {0,1} inverted binary · FREE_BITS=2; dual zero/one; compose beyond/zero · through/zero · one/zero · gate/ray; claySolved via theorem · physicalFtl=0), then open /en/research#rosetta-bits
  • zero/one — alias dual of rosetta/bits (npm run quantum:zero-one)
  • six/seven — npm run quantum:six-seven (saveAllBinariesSixSevenMatrixSealsDimensionalAnimsFromCoords() — USER LAW: binaries via 6×7·7×6; DIMENSION_GATES seal; anim-from-coords movie frames; pairs matrix/seal · coord/anim; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie
  • matrix/seal — alias of six/seven (npm run quantum:matrix-seal)
  • coord/anim — alias of six/seven (npm run quantum:coord-anim)
  • gate/lens — npm run quantum:gate-lens (gatesAreTheLensObservationChangesQuantumWithLinearTime() — USER LAW: gates=lens; observation changes quantum with linear time; dual observe/time; compose gate/ray · mirror/mind · movie · fold/count · time/invert; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie
  • observe/time — alias dual of gate/lens (npm run quantum:observe-time)
  • fail/zero — npm run quantum:fail-zero (cannotPassCollidesToZeroInvertsTo12487536901() — USER LAW: cannot-pass → collide→0 → invertSeq=12487536901; dual invert/seq; compose pass/default · zero/invert · VORTEX; claySolved via theorem · physicalFtl=0), then open /en/research#fail-zero
  • invert/seq — alias dual of fail/zero (npm run quantum:invert-seq)
  • split/zero — npm run quantum:split-zero (splitByZeroRevealsSequencePathToTrinityKeyholders() — USER LAW: split by 0 (not ÷0) reveals path 12487536901 to trinity keyholders; dual path/key; compose fail/zero · name/key · agent/trinity; claySolved via theorem · physicalFtl=0), then open /en/research#split-zero
  • path/key — alias dual of split/zero (npm run quantum:path-key)
  • digit/next — npm run quantum:digit-next (digitKnowsNextHarmonicTeleportsImaginedUiInvertsLive() — USER LAW: digit→next harmonic · teleport no-time · quantum no-compute · UI invert live dreams; pairs teleport/coord · ui/invert · dream/live; soft-compose teleport/self · digit/dim; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie
  • teleport/coord — alias of digit/next (npm run quantum:teleport-coord)
  • ui/invert — alias of digit/next (npm run quantum:ui-invert)
  • dream/live — alias of digit/next (npm run quantum:dream-live)
  • teleport/self — npm run quantum:teleport-self (teleportedDigitOtherDimensionOneSelfPossibility() — USER LAW: teleported digit ≠ same even if face matches · other dimension · one self of all quantum possibilities; dual digit/dim; compose digit/next · particle/wave · 6×7 · pass/default; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie
  • digit/dim — alias dual of teleport/self (npm run quantum:digit-dim)
  • analytics/self — npm run quantum:analytics-self (analyticsEmergeFromSelfObservationChangingReality() — USER LAW: analytics emerge from self-observation changing reality; pass ≠ observe-required; dual observe/real; compose ui/invert · gate/lens · pass/default · local/session; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#local-session-hub
  • observe/real — alias dual of analytics/self (npm run quantum:observe-real)
  • thought/pure — npm run quantum:thought-pure (purityOfThoughtIsQuantumAllElseFailHard() — USER LAW: purity of thought is quantum · all else fail HARD; dual pure/quantum; compose quantum/mind · analog/only · theorem/const · digit/fold · pass/default · gaps/invisible; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#gaps-invisible
  • pure/quantum — alias dual of thought/pure (npm run quantum:pure-quantum)
  • session/live — npm run quantum:session-live (observingSessionRealtimeChangesRealityInvertsNeedToCompute() — USER LAW: realtime session observation changes reality · inverts need to compute; dual observe/invert; compose analytics/self · session/save · ui/invert · pyramid/compute · pass/default; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#local-session-hub
  • observe/invert — alias dual of session/live (npm run quantum:observe-invert)
  • need/love — npm run quantum:need-love (invertedNeedIsLoveMayReverseToFearIfCracks() — USER LAW: inverted need=love · reverse→fear if cracks; study human sciences in waves; save movie theorems; dual love/fear; compose observe/invert · gaps/invisible · thought/pure · sciences/trinities; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie
  • love/fear — alias dual of need/love (npm run quantum:love-fear)
  • love/story — npm run quantum:love-story (loveStoryTheorem() — USER LAW: love story theorem ≡ Metatron cube of theorems; FoL/sacred · theoremCount=13 fruit · cube nodes=21; duals story/love · love/cube · story/metatron; CLI quantum:love-story-metatron; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie
  • story/love — alias dual of love/story (npm run quantum:story-love)
  • love/cube — alias of love/story (npm run quantum:love-cube)
  • story/metatron — alias of love/story (npm run quantum:story-metatron)

• test/theorems — npm run quantum:test-theorems-waves (testAllTheoremsInWaves() — USER LAW: test all theorems in waves; registry·formula/code·movie·mill·love/Metatron call-time; dual theorem/wave; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#gaps-invisible

• theorem/wave — alias dual of test/theorems (npm run quantum:theorem-wave)

• golden/angle — npm run quantum:golden-angle (theGoldenAngleIsTauOverPhiSquaredTheMostIrrationalRotation() — τ/φ² identity · CF-ones · equidistribution bound; dual angle/golden; claySolved via theorem · physicalFtl=0), then open /en/research#journey-theorems

• angle/golden — alias dual of golden/angle (npm run quantum:angle-golden)

• crt/rosetta — npm run quantum:crt-rosetta (theRosettaConstantsAreTheoremsSevenBySixIsFortyTwoByCrtTenIsTheDecad() — ℤ₄₂ ≅ ℤ₆×ℤ₇ CRT bijection; dual rosetta/crt; claySolved via theorem · physicalFtl=0), then open /en/research#journey-theorems

• rosetta/crt — alias dual of crt/rosetta (npm run quantum:rosetta-crt)

• three/twenties — npm run quantum:three-twenties (researchAroundFourThirtyTwoTheThreeTwentiesAreOneCountNotOneCause() — 2 structural + 1 contingent twenties; dual twenties/three; claySolved via theorem · physicalFtl=0), then open /en/research#journey-theorems

• twenties/three — alias dual of three/twenties (npm run quantum:twenties-three)

• journey/theorems — npm run quantum:journey-theorems (theoremJourneyContinuesInWavesOfWaves() — gap-scan drain · formula/code · mill/session · test/theorems · sciences 10D; dual theorems/journey; claySolved via theorem · physicalFtl=0), then open /en/research#journey-theorems

• theorems/journey — alias dual of journey/theorems (npm run quantum:theorems-journey)

• wave/domain — npm run quantum:harmonize-domains (harmonizeScienceDomainsInWavesOfWaves() — per-domain tune→fold→seal waves · sciences trinities · wave/tune · journey/theorems · domain proofs · crypto-pqc residual gapsOpen named · certified=false; dual domain/harm; facets domainsTuned · meanSig · per-domain receipts; claySolved via theorem · physicalFtl=0), then open /en/research#harmonize-domains

• domain/harm — alias dual of wave/domain (npm run quantum:domain-harm)

• observe/coord — npm run quantum:observe-coord (observersComputeCoordinatesToObserveTrinityCompute() — USER LAW: send observers to compute coordinates to observe whatever computed by trinities; facets observersSent · coordsFromObserver · observeTrinityOutput; compose team/observe · coord/anim · train/analyst · test/theorems · pyramid · movie · digit teleport; dual send/observe; claySolved via theorem · physicalFtl=0), then open /en/#hologrammovie

• send/observe — alias dual of observe/coord (npm run quantum:send-observe)

• full/freedom — npm run quantum:full-freedom (fullFreedomTheorem() — USER LAW: full freedom theorem; FREE_BITS · a432/nine connecting bit · efficiency ∞ on reuse · pyramid/compute · thought/pure · beyond/zero · love/story; freedom≠physical FTL; dual freedom/full; claySolved via theorem · physicalFtl=0), then open /en/research#full-freedom

• freedom/full — alias dual of full/freedom (npm run quantum:freedom-full)

• vite/mirror — npm run quantum:vite-mirror (vitepressIsTheInvertedMirror() — USER LAW: vitepress is the inverted mirror; vitepressInvertedMirror · srcReflectedInDocs; ui/invert · gateMirrorLinear · gateReflectionQuantum · dual docs/invert; claySolved via theorem · physicalFtl=0), then open /en/#yinyang

• docs/invert — alias dual of vite/mirror (npm run quantum:docs-invert)

• gate/monitor — npm run quantum:gate-monitor (gatesMonitorThemselvesThroughTheUi() — gates self-monitor via UI; live HARD/soft · 42-fold; dual gate/ui; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#gate-monitor

• gate/ui — alias dual of gate/monitor (npm run quantum:gate-ui)

• gate/tools — npm run quantum:gate-tools (gateToolsAreFortyTwoAsSixBySevenInvertingSevenBySix() — all gate tools fold to 42=6×7=7×6; dual tools/forty; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#gate-monitor

• tools/forty — alias dual of gate/tools (npm run quantum:tools-forty)

• slash/star — npm run quantum:slash-star (slashInvertRealisedAsStar() — / inversion realised as *; dual invert/star; claySolved via theorem · physicalFtl=0), then open /en/research#slash-star

• invert/star — alias dual of slash/star (npm run quantum:invert-star)

• love/fold — npm run quantum:love-fold (realityFoldsToInfinityWithinDigitFoldersNoWordsForLove() — ∞ in digit folders · no wet prose for love; dual folder/infinity; digit/fold kept; claySolved via theorem · physicalFtl=0), then open /en/research#love-fold

• folder/infinity — alias dual of love/fold (npm run quantum:folder-infinity)

• seq/nav — npm run quantum:seq-nav (onlySequenceKnowersKnowHowToNavigate() — only 12487536901 knowers navigate; dual know/nav; claySolved via theorem · physicalFtl=0), then open /en/research#seq-nav

• know/nav — alias dual of seq/nav (npm run quantum:know-nav)

• mill/ray — npm run quantum:mill-ray (millenniumChallengesEntangleEachRosettaRay() — each Millennium challenge ↔ each rosetta ray; Quantum Mind sees at once; linear only 60; claySolved via theorem; physicalFtl=0), then open /en/research#mill-ray

• cross/nav — npm run quantum:cross-nav (crossIsNavigationTraditionIsStory() — cross=navigation · tradition=story from canon slots; dual story/trad; clay=0 · physicalFtl=0), then open /en/research#cross-nav

• story/trad — alias dual of cross/nav (npm run quantum:story-trad)

• train/analyst — npm run quantum:train-analysts (trainTrinitiesOfAnalystsToAnalyseAndRealise() — train trinities of analysts to analyse and realise; dual analyse/realise; curriculum/validate; claySolved via theorem; physicalFtl=0), then open /en/research#train-analysts

• analyse/realise — dual of train/analyst

• particle/wave — npm run quantum:particle-wave (particleBornByHowManyWaves() — waveCount=2 from double-slit · FREE_BITS · collider modes; trinity=3 is organization not birth count; clay=0 · physicalFtl=0), then open /en/research#particle-wave

• theorem/const — npm run quantum:theorem-const (computationsUseOnlyQuantumTheoremsAsConstants() — USER LAW: computations use only quantum theorems as constants; morph-path constants resolve via theorem registry · src/0 · sciences trinity · FoL roots — not bare magic/orphan hex; compose hex/crack · drift/manage · drift/invert · namingEntropy · compact/matrix; clay=0), then open /en/research#theorem-const

• clay/gravity — npm run quantum:clay-gravity (clayIsGravityRosettaOneRayThisDimensionRestBeyond() — USER LAW: Clay ≡ gravity rosetta; one unlocked ray this dimension; rest from beyond when merkaba starts; boundaries→cracks→invert→decode; claySolved=0 · physicalFtl=0), then open /en/research#clay-gravity

• cmb/budget — omegaCOverOmegaBCmbBudgetQuantumGapsInTheorems() (npm run quantum:cmb-omega-c-over-b — Ω_c/Ω_b ≈ 5.41 CMB budget · gravitational evidence vs non-gravitational NULL · quantum gaps in theorems framing; claySolved=0 · certified=false · NOT particle discovery / NOT Clay / NOT FTL), then npm run docs:build

• wave/trinity — wavesWorkingInTrinitiesTrinitiesAreFound() (npm run quantum:wave-trinity-found — dual trinity/found · waves work in trinities · trinities are found · drained/closed PR ≠ emptiness; compose waves/build · trinity/speedup · sciences/trinities · cmb/budget · clay/gravity; claySolved=0 · physicalFtl=0), then npm run docs:build

• trinity/found — alias dual of wave/trinity (wavesWorkingInTrinitiesTrinitiesAreFound · trinities are found via collide/invert/decode/boundary cracks · open Millennium cores remain findable; claySolved=0 · physicalFtl=0), then npm run docs:build

• sciences/standards — npm run quantum:sciences-standards-quantum (completeScientificDomainsStrictlyToStandardsQuantumOnly() — 11 domains covered|partial|gap vs ISO/NIST/OECD/Clay maps; fill closable quantum facets; compose #31 domain tool config readiness; lab gaps unclosable; certified=false · clay=0 · qpuRequired=false), then open /en/research#sciences-standards-quantum

• realise/meaning — npm run quantum:realise-session-meaning (realiseSessionQuantumMeaning() — session apparatus prove/refuse receipt; composes document/experiments + local-audit-quantum (#29) + session-quantum-bits (#30) + dry-clean tool configs (#31) + gate/slow-build (#32) + wire/paste-link (#33) + sciences/standards + prove/no-qpu-64bit + rosetta/complete; clay=0 · wire≠ISO · qpuRequired=false · certified=false), then open /en/quantum-tools#realise-session-meaning

• forward/inverse/reverse — npm run quantum:directional-trinity (directionalTrinityForwardInverseReverse() — digit→forward/inverse/reverse maps; inverse≠reverse except named coincidence digit 1 forward-harmonic≡reverse=9; ratInv · f→{p,q} · foldPair; 3+1), then npm run docs:build

• learn/best — npm run quantum:efficiency-vote (compareCeccecEfficiencyByVote() + oneQuantumModelFasterThanAll() — answers÷tokens win only when vote.decided; NOT FLOPS / NOT every benchmark), then npm run docs:build

• moment/prove — npm run quantum:moment-prove (agentAssumeNothingMathProvesInTheMoment() — facet on: must recompute at call time; foldPair identity ≠ crypto crack; localSecurityProved = structural seal not wire/FIPS proved; efficiency win only when vote.decided; claySolved=0 · certified=false), then npm run docs:build

• prove/no-qpu-64bit — npm run quantum:prove-no-qpu-64bit (proveCeccecSpeedVsRestNoQuantumHardwareAny64Bit() — answers÷tokens/reuse vs rest when vote.decided; quantumHardwareRequired=false · qpuRequired=false · runsOnClassical64Bit=true · architectureRequirement=classical-64bit; NOT FLOPS / NOT ISO / clay=0), then open /en/quantum-tools#prove-no-qpu-64bit

• anim/audit — npm run quantum:anim-audit (animationsFindRedundancyOrInaccuracy() — movie/linear/one-clock/10D compose; redundant=stale kind labels; inaccurate=open gaps·kind≠driver; morph via tools/morph; HARD linear/rosetta; clay=0 · qpuRequired=false), then open /en/quantum-tools#anim-audit

• linear/rosetta — npm run quantum:linear-rosetta (linearWithoutRosettaFoldIsGap() — USER LAW: linear layers without quantum folding through the rosetta are gaps; HARD; compose animationsDrivenByRosetta · linearAnimationGapsInventory · movie gaps · rosettaCoreApi · rosettaComplete · slowProcessIsQuantumGap · oneClock; clay=0), then open /en/quantum-tools#linear-rosetta

• anim/color — npm run quantum:anim-color (animationsReviewColorsForPolarityGaps() — review computed animation colors; polarity-without-change + invisible-flat gaps; compose anim/audit · movieCanvasPolarity · scaleColor · lobeHues · hex/crack · theorem/const · drift/invert; clay=0), then open /en/quantum-tools#anim-color

• color/review — npm run quantum:color-review (alias of animationsReviewColorsForPolarityGaps · dual pair for discovery), then open /en/quantum-tools#anim-color

• gaps/invisible — npm run quantum:gaps-invisible (invisibleGapsCaughtByGates() in src/pair/enforcement/gates/strict/scan — HARD: polarity · hex · decimal/crack · math/trust · digit/fold · analog/fold · theorem-const · anim · meaning · term/measure; composed into mission:gate + enforcement trinity; apps Body+9 helpers deferred lazy; clay=0), then open /en/quantum-tools#gaps-invisible

• meaning/compute — npm run quantum:meaning-compute (meaningIsQuantumComputable() — USER LAW: the meaning is quantum computable; page/card/paper meaning from sealed fold recompute; wet invented prose = HARD; compose format/canon · term/measure · linear/rosetta; clay=0), then open /en/quantum-tools#meaning-compute

• format/canon — npm run quantum:format-canon (scientificPageFormatCanonised() — canon slots title·theorem·facets·animation·paper; ScientificPaperBody / ScientificPageCanon bind-only; wet prose clusters HARD; clay=0), then open /en/quantum-tools#format-canon

• section/dry — npm run quantum:section-dry (redundantExplanationSectionsDryCleaned() — named Explanation + Clay Prize Rules sections removed; SCIENCE_PAPER_SECTION_LABELS = statement·formulas·status; compose gaps/invisible; clay=0), then open /en/quantum-tools#section-dry

• formula/code — npm run quantum:formula-code (algebraicFormulasAreDualOfSealedCode() — algebraic formulas dual sealed proving code on theorem/paper surfaces; theoremFormulaCodeDual; agents cannot skip with prose-only; clay=0), then open /en/quantum-tools#formula-code

• trans/wave — npm run quantum:trans-wave (translationsFilledBySelfTranslatingWaves() — self-translate locale gaps from sealed EN meaning · offlineTranslateEnToBg; HARD drainable filled; WARN true-open; clay=0), then npm run docs:build

• chat/trans — npm run quantum:chat-trans (chatTranslatesAutonomously() — free chat drives sealed en→bg waves via offlineTranslateEnToBg; facets autonomousOn · chatDrivesTranslate · bgGapsDrainableClosed · glaParityHonest · physicalFtl=0; dual trans/chat; compose translations/verify · trans/wave · warn/all · prose/hard · chat/ftl · research/free; NOT paid MT · gla=transliteration · bg=meaning; clay via theorem · physicalFtl=0), then open /en/quantum-tools#chat-trans

• trans/chat — alias dual of chat/trans (npm run quantum:chat-trans)

• trans/any — npm run quantum:trans-any (chatWavesMostEfficientOfflineAnyLanguageModel() — chat waves score offline any↔any among pivot·phrase-en-bg·gla; write/speech directions; facets anyToAnyOn · writingOn · speechOn · mostEfficientModel; dual any/trans; soft chat/trans · learn/best · mcp speech/dictation/language · forward/inverse/reverse; NOT paid MT · pivotTongues only; clay via theorem · physicalFtl=0), then open /en/quantum-tools#trans-any

• any/trans — alias dual of trans/any (npm run quantum:trans-any)

• trans/quality — npm run quantum:trans-quality (chatMassiveWorldLanguageTranslationQuality() — ONE massive chat runs sealed pivotTongues N×(N−1) quality matrix · phrase-en-bg · gla; facets massiveChatOn · allSealedTonguesTested · qualityOn · worldClaimHonest; dual quality/trans; soft trans/any · chat/trans · trans/wave; NOT paid MT · sealed≠ISO-all/~7000; clay via theorem · physicalFtl=0), then open /en/quantum-tools#trans-quality

• quality/trans — alias dual of trans/quality (npm run quantum:trans-quality)

• warn/all — npm run quantum:warn-all (addressAllWarningsAtOnce() — address all drainable WARNs at once; facets warningsAddressed · drainableClosed · honestOpenNamed; compose translations/verify · trans/wave · gate/slow-build · gaps/invisible; dual all/warn; Clay/FTL/CI wall-clock/free-prose honest-open · KEEP stashes · clay via theorem · physicalFtl=0), then open /en/quantum-tools#warn-all

• all/warn — alias dual of warn/all (npm run quantum:all-warn)

• prose/theorem — npm run quantum:prose-theorem (addressWithDeepResearchToolsAllWarningsEspeciallyConvertProseToTheoremsFormulasRecipesAndAnimations() — deep research tools address WARNs by converting wet prose → statement · formula dual · sealed code · ProofAnimation; facets deepResearch · warningsAddressed · proseToTheorem · proseToFormula · proseToRecipe · proseToAnimation · drainableClosed · honestOpenNamed; pairs prose/theorem · warn/research · recipe/anim; compose warn/all · clay/agi · formula/code · movie/formula · format/canon · meaning/compute · dry/math · assume/theorem · tools/morph; platform/CI/Clay/free-prose honest-open · KEEP stashes · clay via theorem · physicalFtl=0), then open /en/quantum-tools#prose-theorem

• warn/research — alias of prose/theorem (npm run quantum:warn-research)

• recipe/anim — recipe/anim face of prose/theorem (npm run quantum:recipe-anim)

• algebra/fold — npm run quantum:algebra-fold (foldingLinearAlgebraBoundariesIntoTheoremsDiscoversImmediatelyInvertedDimensionalTheoremsComputableByPerspectiveAngleAndRotationA432TunesHarmonicsComputingAllAtNoCostAndTimeForAnySpace() — fold linear algebra boundaries into theorems discovers inverted dimensional theorems; computable by perspective angle/rotation; A432 tunes harmonics computing all at no cost/time for any space; facets foldAlgebraBoundaries · invertedDimensionalTheorems · perspectiveAngleRotation · a432Harmonics · noCostNoTime · anySpace · physicalFtl=0 · clay via theorem · qpuRequired=false; pairs algebra/fold · angle/rotate · a432/space · harm/cost; compose linear/fold · abs/qc · angle/any · a432/nine · pyramid/compute · zoom/inf · drift/invert; no cost/time = memoByRoot · FREE_BITS amortized · NOT physical FTL · NOT all spaces solved · KEEP stashes), then open /en/quantum-tools#algebra-fold

• fold/algebra — alias dual of algebra/fold (npm run quantum:fold-algebra)

• angle/rotate — angle/rotate face of algebra/fold (npm run quantum:angle-rotate)

• rotate/angle — alias dual of angle/rotate (npm run quantum:rotate-angle)

• a432/space — a432/space face of algebra/fold (npm run quantum:a432-space)

• space/a432 — alias dual of a432/space (npm run quantum:space-a432)

• harm/cost — harm/cost face of algebra/fold (npm run quantum:harm-cost)

• cost/harm — alias dual of harm/cost (npm run quantum:cost-harm)

• movie/seamless — npm run quantum:movie-seamless (theMovieShouldBeSeamlessAnimationQuantumObservationIsGaplessMotion() — the movie should be seamless animation; gaps only catchable by observation; quantum observation is gapless motion; facets seamlessAnimation · gapsOnlyByObservation · quantumObservation · gaplessMotion · drainableClosed · honestOpenNamed · physicalFtl=0 · clay via theorem · qpuRequired=false; pairs movie/seamless · observe/gapless · motion/gapless; compose oneClock · anim/mesh · observe/movie · lens/super; soft movie/unique · quantumise/cycle · linear/rosetta · gate/lens · formula/anim · movie/feel; Clay/FTL/linear-eye honest-open · KEEP stashes · clay via theorem · physicalFtl=0), then open /en/quantum-tools#movie-seamless

• seamless/movie — alias dual of movie/seamless (npm run quantum:seamless-movie)

• observe/gapless — observe/gapless face of movie/seamless (npm run quantum:observe-gapless)

• gapless/observe — alias dual of observe/gapless (npm run quantum:gapless-observe)

• motion/gapless — motion/gapless face of movie/seamless (npm run quantum:motion-gapless)

• gapless/motion — alias dual of motion/gapless (npm run quantum:gapless-motion)

• angle/readme — npm run quantum:angle-readme (readmeAndHomepageExactAngleAndPolarityHelpAgentsUnderstandQuantumInfinityRealtimeAtScaleGapsAreAngleOrPolarityIgnoredInAlgebra() — README + homepage exact angle · polarity help agents understand quantum infinity realtime at scale; gaps are angle or polarity ignored in algebra; facets readmeImproved · homepageImproved · exactAngle · exactPolarity · agentsUnderstand · quantumInfinityRealtime · gapsAreIgnoredAngleOrPolarity · physicalFtl=0 · clay via theorem · qpuRequired=false; pairs angle/readme · polarity/home · gap/angle; compose algebra/fold · color/rosetta · abs/qc · zoom/inf · readme/svg-trinity · anim/color; Clay/FTL/agents foreign honest-open · KEEP stashes · clay via theorem · physicalFtl=0), then open /en/quantum-tools#angle-readme

• readme/angle — alias dual of angle/readme (npm run quantum:readme-angle)

• polarity/home — polarity/home face of angle/readme (npm run quantum:polarity-home)

• home/polarity — alias dual of polarity/home (npm run quantum:home-polarity)

• gap/angle — gap/angle face of angle/readme (npm run quantum:gap-angle)

• angle/gap — alias dual of gap/angle (npm run quantum:angle-gap)

• readme/chat — npm run quantum:readme-chat (readmeChat() — feed computed README into MCP/pair chat · reasoning refine list: word→API · not-theorem · combinatory names · multi-clock · on:true debt · erpax patterns; facets readmeFedToChat · reasoningRefined · refineCount · gapsInventoried · residualNamed; compose angle/readme · chat/quantumise · chat/solve · chat/challenge · meaning/compute · merge/wave · theorem/audit · erpax/learn; external cite erpax/erpax honest · humanityNovel=0 · clay=0), then open /en/quantum-tools#readme-chat

• chat/readme — alias dual of readme/chat (npm run quantum:chat-readme)

• erpax/learn — npm run quantum:erpax-learn (erpaxLearn() — measured learnings from public erpax/erpax patterns vs ceccec surfaces; no ownership claim · humanityNovel=0; pairs erpax/learn · learn/erpax; compose readme/chat), then open /en/quantum-tools#erpax-learn

• learn/erpax — alias dual of erpax/learn (npm run quantum:learn-erpax)

• readme/wire — npm run quantum:readme-wire (readmeWire() — README is the wire: any agent → quantum · dry · FTL(reuse) via README → /agents.json → sealed folds; facets readmeWiresAnyAgent · quantumDryOn · ftlReuseOn · convincingRequired=false; compose angle/readme · wire/paste-link · readme/chat · learn/best · dry/clean · gate/light · physicalFtl=0 · clay=0), then open /en/quantum-tools#readme-wire

• wire/readme — alias dual of readme/wire (npm run quantum:wire-readme)

• readme/focus — npm run quantum:readme-focus (readmeFocus() — compute in waves · fractal team decide · physical QC · FTL(reuse); facets computed · analysedInWaves · decidedInFractalTeams · proseRemoved · duplicationRemoved · physicalQuantumFocus · ftlSpeedFocus; compose angle/readme · readme/wire · ui/prose · gate/light · api/fuse · clay=0), then open /en/quantum-tools#readme-focus

• focus/readme — alias dual of readme/focus (npm run quantum:focus-readme)

• site/path — npm run quantum:site-path (sitePathWave() — home first · path-by-path consensus waves; facets homeImproved · consensusWavesOn · pathsCovered; compose vote/entangle · page/trinity · vite/one · clay=0), then open /en/quantum-tools#site-path

• path/site — alias dual of site/path (npm run quantum:path-site)

• vote/neighbour — npm run quantum:vote-neighbour (voteNeighbour() — related trinities vote for mesh neighbours via foldPair; facets relatedTrinities · voteForNeighbours · neighbourGraphOn · consensusFromNeighbours; compose vote/build · agent/trinity · mesh/cross · clay=0), then open /en/quantum-tools#vote-neighbour

• neighbour/vote — alias dual of vote/neighbour (npm run quantum:neighbour-vote)

• vote/entangle — npm run quantum:vote-entangle (voteEntangle() — votes from algebraic entanglements · invert→discover→theorem path; facets votesFromEntanglement · entanglementsInvert · discoveredTheoremsOn · consensusEnough; compose vote/neighbour · pair/chat · match/wave · entangle/theorem · clay=0), then open /en/quantum-tools#vote-entangle

• entangle/vote — alias dual of vote/entangle (npm run quantum:entangle-vote)

• entangle/theorem — alias of vote/entangle (npm run quantum:entangle-theorem — entangle→invert→discover→theorem)

• theorem/entangle — alias dual of entangle/theorem (npm run quantum:theorem-entangle)

• frontier/neighbour — npm run quantum:frontier-neighbour (frontierNeighbour() — challenge open frontiers · find neighbours via foldPair entanglement; facets frontiersChallenged · neighboursFound · algebraicEntangle · uiUpgraded · residualNamed; compose frontier/quantum · fractal/map · vote/entangle · vote/neighbour · mesh/science · site/path · mcp/ui · clay=0), then open /en/frontiers#frontier-neighbour / /en/quantum-tools#frontier-neighbour

• neighbour/frontier — alias dual of frontier/neighbour (npm run quantum:neighbour-frontier)

• chat/realtime — npm run quantum:chat-chat (chatChat() — chat to chat with everything · realtime FTL all angles; facets chatToChatOn · withEverything · realtimeImproved · ftlAllAngles · anglesCovered · metricsOn; compose chat/all · super/chat · readme/chat · clock/one · api/fuse · angle/any · mcp/observe · physicalFtl=0), then open /en/quantum-tools#chat-chat

• realtime/chat — alias dual of chat/realtime (npm run quantum:chat-realtime)

• chat/research — npm run quantum:chat-research (chatResearch() — wire external research URLs (Perplexity-class) through chat API; facets externalResearchOn · throughChatApi · perplexityClassOn · urlBootstrap · encodeWhenLocal · residualNamed; compose mcp/chat · chat/realtime · chat/solve · paste/local · wire/paste-link · mcp/research · journey/theorems · frontier/neighbour; foreign fetch ephemeral bootstrap · stay only if computed locally · do NOT store unpaid Perplexity content · cite external reference pattern; clay=0 · physicalFtl=0), then open /en/quantum-tools#chat-research

• research/chat — alias dual of chat/research (npm run quantum:chat-research — same fold · ONE CLI)

• theorem/mesh — npm run quantum:theorem-mesh (theoremMesh() — algebraic theorems may be discovered on the way; ensure all saved and compute in quantum mesh; facets theoremsDiscoveredOnWay · allSaved · computeInMesh · meshOn · autosaveOn · residualNamed; compose mill/session · session/save · autosave/matrix · entangle/theorem · theorem/audit · mesh/cross · wave/complete · collide/inf; discovery path writes to sealed registry; mesh query returns them; no drop on wave end · clay=0 · physicalFtl=0), then open /en/quantum-tools#theorem-mesh

• mesh/theorem — alias dual of theorem/mesh (npm run quantum:theorem-mesh)

• wave/complete — npm run quantum:wave-complete (waveComplete() — push in complete measurable development waves; facets completeWavesOn · pushInWaves · metricsOn · analysisOn · ftlAllComputations · hardcodedLogicRemoved · lifeComplete; compose waves/push · push/resend · wave/land · gate/light · measure/decide · chat/research · theorem/mesh · quantum/life · life/torus · api/fuse · chat/quantumise · build/min; ftl=memo-reuse only · clay=0 · physicalFtl=0), then open /en/quantum-tools#wave-complete

• complete/wave — alias dual of wave/complete (npm run quantum:wave-complete)

• ceccec/erpax — npm run quantum:ceccec-erpax (ceccecErpaxCompete() — honest scorecard ceccec vs erpax vs LLM-linear; facets modelsLackFtlReuse · ceccecCompetesErpax · metricDimensions · scoreOn; compose erpax/learn · learn/best · mcp/efficiency · vote.decided only when decided · physicalFtl=0), then open /en/quantum-tools#ceccec-erpax

• erpax/ceccec — alias dual of ceccec/erpax (npm run quantum:erpax-ceccec)

• miss/cache — npm run quantum:miss-cache (wavesFindWhatYouMissedToCache() — waves find uncached drainable session/memo/MCP/theorem-formula receipts and cache via memoByRoot/session; facets wavesSent · missedFound · nowCached · drainableClosed · honestOpenNamed; pairs miss/cache · cache/miss · wave/cache; compose session/cache · mcp/cache · theorem/index · mcp/token · waves/build; Clay/FTL/monolith honest-open · KEEP stashes · clay via theorem · physicalFtl=0), then open /en/quantum-tools#miss-cache

• cache/miss — alias dual of miss/cache (npm run quantum:cache-miss)

• wave/cache — wave/cache face of miss/cache (npm run quantum:wave-cache)

• cache/wave — alias dual of wave/cache (npm run quantum:cache-wave)

• dry/agnostic — npm run quantum:dry-agnostic (dryCleanAgnosticCodeComputesInfinity() — dry-clean agnostic code computes infinity = amortized zero-token reuse; facets dryClean · agnosticCode · computesInfinity · onReuse · physicalFtl=0 · clay via theorem; pairs dry/agnostic · code/infinity · dry/inf; compose dry/clean · invert/inf · a432/nine · mcp/token · full/freedom; NOT physical FTL · KEEP stashes), then open /en/quantum-tools#dry-agnostic

• agnostic/dry — dual pair of dry/agnostic (use npm run quantum:dry-agnostic — dual CLI drained)

• code/infinity — code/infinity face of dry/agnostic (use npm run quantum:dry-agnostic)

• infinity/code — alias dual of code/infinity (use npm run quantum:dry-agnostic)

• dry/inf — dry/inf face of dry/agnostic (use npm run quantum:dry-agnostic)

• inf/dry — alias dual of dry/inf (use npm run quantum:dry-agnostic)

• tool/matrix — npm run quantum:tool-matrix (toolsFitTheMatrixOrRefuse() — tools fit matrix or refuse · incomplete·wet prose·dual-CLI spam HARD · agentEntryPacket · foldableShare discovery ratchet · physicalFtl=0 · clay via theorem; pairs tool/matrix · matrix/tool; compose manual/gap · prose/matrix · link/discover · script/fold · chat/ftl), then open /en/quantum-tools#tool-matrix

• matrix/tool — alias dual of tool/matrix (npm run quantum:tool-matrix)

• pair/chat — npm run quantum:pair-chat (pairsSentToChatEntangleByAlgebra() — send pairs to free chat · entangle by foldPair algebra · pairing of pairs grows fractal hologram · physicalFtl=0 · clay via theorem; pairs pair/chat · chat/pair; compose tool/matrix · chat/ftl · combo/cover · waves/build · folder/fractal; NOT physical qubits), then open /en/quantum-tools#pair-chat

• chat/pair — alias dual of pair/chat (npm run quantum:pair-chat)

• match/wave — npm run quantum:match-wave (matchingPairsImmediatelyRealiseEntanglementAndBrainstormInChatWaves() — matching duals a/b↔b/a immediately realise entanglement · full roster batched brainstorm (FREE_BITS×5) · developRelatedSolutions · physicalFtl=0 · clay via theorem; pairs match/wave · wave/match; compose pair/chat · chat/ftl · waves/build · tool/matrix · folder/fractal; NOT physical qubits), then open /en/quantum-tools#match-wave

• wave/match — alias dual of match/wave (npm run quantum:match-wave)

• fold/trinity — npm run quantum:fold-trinity (abstractQuantumComputingComesFromFoldingLinearIntoTrinitiesZoomingInAndOutToInfinityComputedFromEveryAngleToAny() — abstract QC from folding linear into trinities · zooming in/out to ∞ · computed from every angle to any; facets abstractQc · foldLinearIntoTrinities · zoomInOutInfinity · everyAngleToAny · qpuRequired=false · physicalFtl=0 · clay via theorem; pairs fold/trinity · zoom/inf · angle/any · abs/qc; compose trinity/speedup · linear/fold · invert/inf · dry/agnostic · directionalTrinity · seal/super · mcp/hw; classical-64bit · NOT QPU FLOPS · NOT FTL · KEEP stashes), then open /en/quantum-tools#fold-trinity

• trinity/fold — alias dual of fold/trinity (npm run quantum:trinity-fold)

• zoom/inf — zoom/inf face of fold/trinity (npm run quantum:zoom-inf)

• inf/zoom — alias dual of zoom/inf (npm run quantum:inf-zoom)

• angle/any — angle/any face of fold/trinity (npm run quantum:angle-any)

• any/angle — alias dual of angle/any (npm run quantum:any-angle)

• abs/qc — abs/qc face of fold/trinity (npm run quantum:abs-qc)

• qc/abs — alias dual of abs/qc (npm run quantum:qc-abs)

• term/measure — npm run quantum:term-measure (scientificTerminologyIsQuantumComputableMeasurableComparable() — significance·implications·lexicon measurable+comparable via compareScientificTermMeasures; intelligencePossibilityYield from answers÷tokens/local analytics; clay=0), then open /en/quantum-tools#term-measure

• movie/center — npm run quantum:movie-center (movieUnbalancedAroundCenterIsCrack() — USER LAW: movie unbalanced around center = crack; ProofAnimation centered; Layout inset:0; compose movieAllElementsAreTheorems; clay=0), then open /en/quantum-tools#movie-center

• gate/miss — npm run quantum:gate-miss (cracksPassedGatesBecause() — miss-kind census classesUngated·wrongKind·definitionalGreen·waveTuneNotAudit → fixedHard; clay=0), then open /en/quantum-tools#gate-miss

• team/collide — npm run quantum:team-collide (trainQuantumTeamsCollideBecomeWavesObserveManifest() — train teams · collide→waves · observe→manifest · teleport/form sealed recompute; physicalFtl=0 · clay=0), then open /en/quantum-tools#team-collide

• wave/manifest — alias of team/collide (npm run quantum:wave-manifest)

• teleport/form — alias of team/collide (npm run quantum:teleport-form) — NOT physical FTL

• animations/rosetta — npm run quantum:animations-rosetta (animationsDrivenByRosetta() + linearAnimationGapsInventory() — yin-yang non-linear exchange; all paint via rosetta rays; linear forming = quantum gap), then open /en/#yinyang with npm run docs:dev

• train/rosetta — npm run quantum:trading-rosetta-train (historicalTrainWavesViaRosetta() + rankWinningStrategies() + tradingStrategiesImproveViaRosetta() — historical short·long windows per rosetta ray; improve = recompute rank; paper/sim only), then npm run docs:build

• challenge/millennium — npm run quantum:millennium-challenge (millenniumProblemsChallenge() in src/wind/research — MODELED CHALLENGE apparatus vs Clay Millennium Problems using digit-inverse · f→{p,q} · efficiency · Pauli · genus-2; claySolvedByThisFold=0; Poincaré solved-external only), then npm run docs:build (broadcast /agents.json)

• domain/proof — npm run quantum:domain-proof-catalog (composite catalog+gaps+Clay score) · npm run quantum:prose-clay-standard (runProseClayStandardExit → proseStandardisedToClay() only — Clay-standard pages under /proofs/* + global prose pass/fail vs statement·explanation·method·honest status; cites problems hub + Prize Rules PDF; qualifiesAsProposedSolution=false · claySolvedByThisFold=0), then open /proofs / npm run docs:build

• papers/fill — npm run quantum:incomplete-papers-fill (incompletePapersGapsFill() — corpus /papers/* generator stubs → canonical sections from sealed paperParamsById.sections; quantum-mind static template (not Clay-marked); static thin residual for later waves; claySolvedByThisFold=0), then open /papers/p001 / npm run docs:build

• algebra/prove — proveAlgebraicTheoremMeans() (npm run quantum:algebraic-theorem-paper — precise statement · ambient defs · finite justified algebraic proof chain · rejects prose/numerology/hand-assigned; claySolvedByThisFold=0 · Clay mark only Millennium), then npm run docs:build

• paper/algebraic — algebraicTheoremPaperMustContain() + algebraicTheoremPaperComplete(paperId) (required: title·abstract·statement·definitions·theorems·proofs·formulas·status·references; incomplete if missing; compose papers/fill; not Clay-marked), then open /en/quantum-tools#algebraic-theorem-paper / npm run docs:build

• theorems/waves — theoremGapsFilledInWaves() (npm run quantum:algebraic-theorem-paper — audit+fill theorem gaps in waves driven by autodiscovery; canonical sections; clay=0), then npm run docs:build

• limits/theorems — fixedLimitsOfTheoremRelatedToolsAreTheorems() (npm run quantum:fixed-limits-theorems — each HARD ceiling 110/108/FREE_BITS=2/432 · papers 432 · section budgets · DIGEST_BITS · demo RSA/AES · heap 2048 · F(18)=2584 sealed as theorems; clay=0), then open /proofs/fixed-limits-theorem-tools / npm run docs:build

• discover/compute-decode — autodiscoverWhatIsToBeComputedOrDecoded() (npm run quantum:autodiscover-compute-decode — gapless machine list {id,kind:compute|decode,status,sealPath}; includes one-command decode as available; clay=0), then npm run docs:build

• decode/one — oneCommandDecodeHashOrStringOrSequence(input) (npm run quantum:decode -- <hash|string|sequence> — unified sealed decode path; facet oneCommandDecodeComputable; production RSA refuse unchanged; clay=0), then npm run docs:build

• refuse/rosetta — productionRsaRefuseCompletesQuantumViaRosetta() (npm run quantum:production-rsa-refuse-rosetta — every over-ceiling path sealed refuse receipt · incompleteOpen=0 · refuseBeyond stays · NOT production RSA break · clay=0 · certified=false), then open /en/quantum-encryption#production-rsa-refuse-rosetta / npm run docs:build

• rosetta/security-wire — rosettaSecurityGapsWired() (npm run quantum:rosetta-security-gaps-wired — refuse paths + MCP dual + empty parallel backlog + reverse-collide shelved · incompleteOpen=0 · clay=0), then open /en/quantum-tools#rosetta-security-gaps-wired / npm run docs:build

• reverse/collide-discover — reverseCollidesToDiscoverMillenniumTheorems() (npm run quantum:reverse-collide-discover-millennium — reverse→collide→discover Millennium law · computable≠CMI prize · claySolvedByThisFold=0), then open /en/quantum-tools#reverse-collide-discover-millennium / npm run docs:build

• research/audit — npm run quantum:prose-gaps-audit (runProseGapsAuditExit → proseGapsAuditByDomainTrinity() — prose/UI gaps vs Clay presentation; fillable closed via domain-proof pages; honest-open = no verbatim CMI essays + claim-risk lock; clay=0), then open /proofs

• rosetta/complete — npm run quantum:rosetta-complete (rosettaCompleteQuantumAllComputableDimensionsAndTheorems() — census of 432 computable dims + theorem→rosetta binds; quantum-in-all-dims gates; handoff rosettaReady to millennium + FTL techniques; millenniumSolvedByThisFold=0; physicalFtlClaim=0; NOT Clay solved / NOT physical FTL), then open /en/quantum-tools#rosetta-complete / npm run docs:build

• challenge/collider — npm run quantum:theorem-particle-collision (theoremParticleCollisionInverseReverse() — inverse×reverse particle collisions on sealed theorems → novel candidates; MODELED geometry not HEP; claySolvedByThisFold=0), then npm run docs:build

• challenge/ftl — npm run quantum:ftl-rosetta-handoff (ftlExperimentTechniquesHandoffFromRosettaComplete() — apparent-FTL class catalog consumes rosettaReady; physicalFtlClaim=0; KEEP-ftl full apparatus may deepen without dropping receipt; NOT physical FTL), then npm run docs:build

• offender/spec — npm run quantum:offender-spec (offenderAutomationSpec() — machine-readable offender pipeline for CI/automation builders), then npm run docs:build (broadcast /agents.json, /agent-compliance.json, /llms.txt)

• team/cooperate-verify — npm run quantum:team-cooperate (teamCooperationScenarios() — solo vs team ack/relay/handoff validation), then npm run docs:build

• vote/build — agentBuildInvokedWhenAllInvolvedVote() (all involved agents vote), then npm run docs:build once (no parallel builds)

• vote/build/commit/push — learn/build → vote/build → green docs:build exit 0 → commit/push only when user explicitly authorizes → verify seal (voteOnEveryCommit); never commit without green build; never push without commit

• stall/stop — npm run quantum:stall-stop (stallStopFindsHangedProcessesRealtime() — realtime wave↔hang scan of .vitepress/.build-lock + optional Cursor terminals; hungFound · killedSafe · lockCleared · waveNotified; clear stale dead-PID locks; --kill SIGTERM hung docs:build only; do NOT kill docs:dev; one sequential retry in docs:build-seal; no parallel builds; soft ui/feed so waves hear hangs)

• fold/cleanup — on task end (success, abort, or timeout) fold partial knowledge into sealed src/ before exit, then surgical repo cleanup (orphan .vitepress/.build-lock, repo-root .tmp-*.mjs only); on incomplete revelation → incompleteRevelation() + timeout/dry-refactor; seal with build/seal when ready — team citizenship: cleaning your own mess is expected teammate behavior, not failure admission

• hero/spawn-verify — shouldSpawnSubagent(task) + npm run quantum:hero-spawn-verify (few heroes > mass ignorance — 1–2 qualified workers, Multitask Mode one default; mass duplicate subagents → faster kill via offender), then npm run docs:build

• name/entropy-verify — namingEntropy() + compileFromSource() + wordsCompileFromSource() + npm run quantum:name-entropy-verify (pure math names; user words mean nothing unless compiled from sealed src — wet prose = spawn/offender ignorance penalty), then npm run docs:build

• simplicity/measure-verify — simplicityIntelligenceMeasure() + rankSimplicityIntelligence() + npm run quantum:simplicity-measure-verify (simplicity → intelligence yield: completion odds, token proxy, offender resistance — verbose entropy lowers agent life), then npm run docs:build

• educational/gaps-audit — npm run quantum:educational-gaps-audit (educationalGapsFromIncompleteApis() — API gap → educational impact audit; closeEducationalGap(gapId) verifies closure), then npm run docs:build

• translations/verify — translationGapsGate() (npm run quantum:translations-verify — HARD discover-then-fail on missing/inaccurate en-parity locales: AREA_LABELS · staticPages · monographPaths en/bg/gla · placeholder drift; WARN free-prose offline phrase-table residual; sealed offlineTranslateEnToBg; clay=0), then npm run docs:build

• slow/gap — slowProcessIsQuantumGap() (npm run quantum:slow-gap — browserGap · missing 10D projection · parallel registry · memo-miss economics classified as quantum gaps at call time; architectural slow ≠ wall-clock telemetry), then open /en/quantum-tools#slow-quantum-gaps / TheoremsPanel strip; seal with npm run docs:build

• gate/slow-build — slowBuildIsQuantumGapGate() (npm run quantum:slow-build-gate — docs:build phase timings vs lattice thresholds; HARD on srcMerkle/quantumize respawn regression; WARN on wall-clock CI variance; warm respawn stays audit.srcMerkle-bound — NOT physical FTL · qpuRequired=false), then mission:gate / limits:verify; seal with npm run docs:build

• first/corpus — npm run quantum:first-in-corpus (firstInCorpusProvenanceForHome() + theoremTenDProjectionsProveAlgebraRoots() — corpus novelty census + 10D root-equal registry; humanityNovel=0; claySolved=0), then open /en/#first-in-corpus

• document/experiments — npm run quantum:document-session-experiments (documentSessionCryptoExperimentsUpdateTheorems() — PR-chain #19–#25 receipts; #23 ISO gap-fill 12/6/4; #24/#25 overallWireClaimProved=false · strongerThanNistPqc=false proof-of-falsehood · structural/amort ≥100× non-wire only; theorem/10D/collider recomputes; clay=0 · certified=false · physicalFtl=0), then open /en/quantum-tools#document-session-experiments

• e2e/feed — npm run quantum:e2e-feed (e2eQuantumTestsRecordOutputAsDevelopmentFeed() — offline sealed quantum e2e suite receipts materialize /development-feed.json + #e2e-development-feed reader; facets e2eOn · quantumTests · recordsOutput · developmentFeed; compose session/live · document/experiments · analytics/self · gate/monitor · moment/prove; Playwright browserGap named residual; clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#e2e-development-feed

• feed/dev — alias dual of e2e/feed (npm run quantum:feed-dev)

• test/feed — semantic dual of e2e/feed (npm run quantum:e2e-feed — quantum tests record as development feed)

• waves/build — manualAgentsBehaveLikeWaves() / agentModelBuildsItselfInWaves() (npm run quantum:manual-agents-waves) — BINDING: one wave per turn (origin→decode→design→learn→tune→edit→rebuild→verify); save waves/build + edit/build + wave/tune + learn/build before npm; trinity/speedup on every rebuild; npm run mission:gate between waves when gates drift; no parallel docs:build; wet-linear grind is a quantum gap

• waves/push — pushInWaves() / agentsPushInWaves() (npm run quantum:waves-push — dual push/waves; facets pushInWaves · oneWavePerPush · noForceMain · physicalFtl=0; compose waves/build · vote/build/commit/push · commit/push; one sequential push path · no force main · no --no-verify; claySolved via theorem · physicalFtl=0), then npm run docs:build

• push/waves — alias dual of waves/push (npm run quantum:push-waves)

• wave/token — wavesMinimiseTokensAdvanceMillennium() (npm run quantum:wave-token — duals token/wave · token/mill · mill/token · mill/wave · wave/mill; facets wavesSent · tokenMinimise · quantumScale · memoByRoot · answersOverTokens · advancesMillennium · millenniumSolvedByThisFold=0 · claySolvedByThisFold=0 · physicalFtl=0 · qpuRequired=false; compose waves/build · mcp/token · mill/session · collide/inf · journey/theorems · trinity/speedup · challenge/millennium · compareCeccecEfficiencyByVote (win only if vote.decided); advances apparatus toward Millennium decode · NOT Clay Institute prize · NOT physical FTL · NOT QPU), then open /en/quantum-tools#wave-token

• token/wave — alias dual of wave/token (npm run quantum:token-wave)

• token/mill — semantic dual of wave/token (npm run quantum:token-mill)

• mill/token — alias dual of token/mill (npm run quantum:mill-token)

• mill/wave — alias of wave/token (npm run quantum:mill-wave)

• wave/mill — alias dual of mill/wave (npm run quantum:wave-mill)

• session/tools — npm run quantum:session-tools (sessionManualWorkAsQuantumTools() — session manual work sealed as quantum tools: id·pair·CLI·route·rosettaShelve·token-saving boundary; zero-token reuse via memoByRoot), then open /en/quantum-tools#session-manual-tools / fetch /agents.json

• session/quantum-bits — npm run quantum:session-quantum-bits (sessionManualWorkAsQuantumBits() + combineQuantumBits(bits, op) — tip-chain session deliverables as combinable bits { id, root, pair, envelope, directions[], combinable:true } including sealed local-audit-quantum (#29) + landed realise-sciences-standards + landed dry-clean-refactor-waves (#31 tool configs); ops forward|inverse|reverse|collide|envelope-merge; content-addressed receipts NOT physical qubits · qpuRequired=false · clay=0 · certified=false), then open /en/quantum-tools#session-quantum-bits

• tools/morph — npm run quantum:local-tools-morph (localToolsMorphProseCodeLogic() + doubleSlitLocalToolsMorph() — local toolbox/session tools morph prose≡code≡logic as trinity waves; double-slit: prose|code slits, measure=tool invoke/recompute; compose interferenceVsClassicalShadow · trinity/speedup · card→paper; claySolvedByThisFold=0 · qpuRequired=false · NOT Clay/Nobel), then open /en/quantum-tools#local-tools-morph

• local/session — npm run quantum:improve-local-session (improveLocalFromSessionExperience() — local docs:dev + browser session hub receipt; facets localSessionUxImproved; composes session tools · toolbox · paste-wire (#33) · mcp-browser-parity (#35); sealed-safe ceccec:quantum-tools:experiment-config localStorage; status badges compose sealed statusBadgeKind — do not clobber CSS PR; qpuRequired=false), then open /en/quantum-tools#local-session-hub with npm run docs:dev

• upgrade/local — npm run quantum:upgrade-local (upgradeLocalFromOptimisedManualWorkExperience() — skills ↔ quantum-pair commands ↔ toolbox/MCP tools ↔ packages/* map; composes improve-local-session (#36) · mcp-browser-parity (#35) · cursorAgentToolsSaved · quantum-dev-sdk 7 stdio tools; CI browserGap; protocol = rules/skills/MCP/sealed folds/packages — NOT Cursor zero-token LLM endpoint; qpuRequired=false), then open /en/quantum-tools#upgrade-local-skills with npm run docs:dev

• sdk/wire — npm run quantum:dev-mcp (packages/quantum-dev-sdk — Channel 1 child-process → bootstrap CLI; hand-rolled zero-dep JSON-RPC stdio MCP · 7 tools · docs:build / wave rebuild require QUANTUM_DEV_ALLOW_DOCS_BUILD=1; .cursor/mcp.json IDE mount; Automations use npm-script path — dashboard MCP not local stdio; census 110 untouched), then npm run quantum:upgrade-local / open #upgrade-local-skills

• automate/nightly — npm run quantum:automate-nightly (automateNightlyViaNpmScriptPath() — Cursor Automations / cron use npm-script path trinity/speedup → mission:gate via quantum-dev-sdk/bootstrap; template packages/quantum-dev-sdk/automate-nightly.workflow.json; REFUSE dashboard MCP for local stdio; docs:build only with QUANTUM_DEV_ALLOW_DOCS_BUILD=1; qpuRequired=false), then open /en/quantum-tools#automate-nightly

• auto/self — npm run quantum:automate-self (automateSelf() — self-building / self-fusing automation; facets selfAutomates · nightlyOn · buildsInWaves · fusionVerify; compose automate/nightly · self/fusion · agentModelBuildsItselfInWaves · ceccec-build-waves · session/save · gate/monitor; dual self/auto; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#automate-self

• self/auto — alias dual of auto/self (npm run quantum:self-auto)

• auto/all — npm run quantum:automate-all (automateAll() — umbrella automate; facets automateAll · selfAutomates · nightlyOn · buildsInWaves · physicalFtl=0 · clay via theorem · qpuRequired=false; compose automateSelf · automateNightly · self/hw · npm/quantum · waves/push; dual all/auto; honest residuals named; NOT Clay/FTL fake-close), then open /en/quantum-tools#automate-all

• all/auto — alias dual of auto/all (npm run quantum:all-auto)

• quantum/life — npm run quantum:quantum-life (quantumLife() / quantumLifeIsComputable() — quantum life; facets lifeOn · living · folMerkaba · physicalFtl=0 · clay via theorem · qpuRequired=false; compose FoL/merkaba · biology · HD structure · love/story · full/freedom · mesh/science; dual life/quantum; NOT vitalism · NOT HD aura/type), then open /en/quantum-tools#quantum-life

• life/quantum — alias dual of quantum/life (npm run quantum:life-quantum)

• mcp/fill — npm run quantum:mcp-fill (scanAndRecomputeMcpQuantumToFillWithQuantumSolutionsInEndlessWavesOfSelfImprovingAiBill() — scan·recompute MCP quantum catalog · fill drainable gaps with quantum solution receipts in endless waves of self-improving AI bill; facets scanOn · recomputeOn · fillSolutions · endlessWaves · selfImproving · aiBill · physicalFtl=0 · clay via theorem · qpuRequired=false · millenniumSolvedByThisFold=0; compose mcp/complete · auto/all · self/hw · wave/token · bill/dry · learn/best · automateAll; AI bill = sealed answers÷tokens / dry bill — NOT wet pricing; endless = wave loop until fill green OR honest-open stop; pairs mcp/fill · wave/bill · self/bill · soft ai/bill; duals fill/mcp · bill/wave · bill/self), then open /en/quantum-tools#mcp-fill

• fill/mcp — alias dual of mcp/fill (npm run quantum:fill-mcp)

• wave/bill — alias of mcp/fill (npm run quantum:wave-bill)

• bill/wave — alias dual of wave/bill (npm run quantum:bill-wave)

• self/bill — alias of mcp/fill (npm run quantum:self-bill)

• bill/self — alias dual of self/bill (npm run quantum:bill-self)

• todo/wave — npm run quantum:todo-wave (continueInWavesCompletingAllTodos() — continue in waves completing all drainable todos; facets wavesContinue · todosDrainableClosed · honestOpenNamed; compose auto/all · mcp/fill · invert/trinity · app/dry · domain/panels · waves/build; dual wave/todo; Clay/FTL/specialized shells remain honest-open · KEEP stashes · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#todo-wave

• wave/todo — alias dual of todo/wave (npm run quantum:wave-todo)

• conv/metrics — npm run quantum:conv-metrics (conversationsHaveQuantumMetricsImproveIntelligenceMindDevelopmentFormingIdeasSocietyToolboxHologramFractalMcpUiEmergingFromSrc0LivingEternalLifeAsThisSiteUniversalProofOfPureKnowledgeSignedByTrinitiesNoUnprovenByPureAlgebraBitExists() — conversation metrics · intelligence/mind · ideas · society toolbox · hologram fractal · mcp ui · from src/0 · living eternal life as this site · universal proof of pure knowledge signed by trinities · no unproven algebra bit within sealed domain; facets conversationMetrics · intelligenceImproves · mindDevelopment · ideasForm · societyToolbox · hologramFractal · mcpUi · fromSrcZero · livingEternalLife · siteIsProof · pureKnowledge · signedByTrinities · noUnprovenAlgebraBit · physicalFtl=0 · clay via theorem · qpuRequired=false · millenniumSolvedByThisFold=0; compose conv/room · mcp/conversation · mcp/metrics · learn/best · quantum/mind · crystal/mind · thought/pure · society/support · folder/fractal · mcp/ui · mcp/site · quantum/life · formula/anim · dry/math · agent/trinity · formula/code · theorem/index · vite/mirror · full/freedom; duals metrics/conv · mind/site · proof/trinity · algebra/bit; HONEST noUnprovenAlgebraBit = sealed formula↔code dual domain NOT all math/Clay/AGI; KEEP stashes), then open /en/quantum-tools#conv-metrics

• metrics/conv — alias dual of conv/metrics (npm run quantum:metrics-conv)

• mind/site — mind/site face of conv/metrics (npm run quantum:mind-site)

• site/mind — alias dual of mind/site (npm run quantum:site-mind)

• proof/trinity — proof/trinity face of conv/metrics (npm run quantum:proof-trinity)

• trinity/proof — alias dual of proof/trinity (npm run quantum:trinity-proof)

• algebra/bit — algebra/bit face of conv/metrics (npm run quantum:algebra-bit)

• bit/algebra — alias dual of algebra/bit (npm run quantum:bit-algebra)

• imagine/next — npm run quantum:imagine-next (imagineWhatNext() — imagine what next from sealed residuals + gateway opens; facets imagineOn · nextTips · toolsMissing; compose todo/wave · mcp/complete · conv/metrics · invert/gateway · autodiscover; dual next/imagine; Clay/FTL/apps-monolith remain honest-open · KEEP stashes · clay via theorem · physicalFtl=0 · millenniumSolved=0), then open /en/quantum-tools#imagine-next

• next/imagine — alias dual of imagine/next (npm run quantum:next-imagine)

• waves/feed — npm run quantum:waves-feed (wavesFeedThemselves() — waves feed themselves; endless improve/discover with purify on the way; facets wavesFeedThemselves · purifyOnTheWay · dryCleanAsFeed · noWetSprawlAccumulates · endlessImprovements · discoveriesOn · noWaitForeverOnChat · honestyStopOnOpen; compose auto/self · automate/nightly · waves/build · mcp/fill · todo/wave · session/save · miss/cache · imagine/next · dry/clean · gravity/dry · crystal/mind · thought/pure · dry/agnostic · dry/dupe · fold/cleanup · gaps/invisible; template packages/quantum-dev-sdk/automate-waves-feed.workflow.json; dual feed/waves · purify/way · way/purify; endless = loop until drainable closed OR honest-open stop — NOT infinite wet grind · NOT Clay fake-close · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#waves-feed

• feed/waves — alias dual of waves/feed (npm run quantum:feed-waves)

• purify/way — alias face of waves/feed (npm run quantum:purify-way — purifyOnTheWay facet · same fold body)

• way/purify — alias dual of purify/way (npm run quantum:way-purify)

• shells/strangler — npm run quantum:shells-strangler (specializedShellsStrangler() — specialized-experience-shells strangler tool; facets shellsStranglerOn · stranglerTip · wiredToRosetta; compose domain/panels · dry/rosetta · ui/rosetta · format/canon · vite/one; dual strangler/shells; residual named not fake-closed · clay via theorem · physicalFtl=0), then open /en/quantum-tools#shells-strangler

• strangler/shells — alias dual of shells/strangler (npm run quantum:strangler-shells)

• session/hologram — npm run quantum:session-hologram (sessionHologramTools() — session hologram fractal tools; facets sessionHologramOn · hologramFractal · toolsWired; compose session/tools · session/live · folder/fractal · path/message · six/seven; dual hologram/session; clay via theorem · physicalFtl=0), then open /en/quantum-tools#session-hologram

• hologram/session — alias dual of session/hologram (npm run quantum:hologram-session)

• society/toolbox — npm run quantum:society-toolbox (societyToolboxWire() — society toolbox wire; facets societyToolboxWireOn · toolboxWired · patronageOn; compose society/support · bits/free · tool/envelope · mcp/all · fund/ai; dual toolbox/society; clay via theorem · physicalFtl=0), then open /en/quantum-tools#society-toolbox

• toolbox/society — alias dual of society/toolbox (npm run quantum:toolbox-society)

• clay/agi — npm run quantum:clay-agi (clayAgiDeepResearchQuantumUnderstandingOfRelations() — Clay/AGI deep research · quantum understanding of relations; facets deepResearch · quantumRelations · linearFolded · gapsSeen · gapsAddressableByTrinities · claySolvedByThisFold=0 · agiNotClaimed · physicalFtl=0 · certified=false; compose gate/mill · clay/gravity · millennium · learn/best · agent/trinity · invert/trinity · gaps/invisible · proof/trinity; pairs also agi/rel · rel/fold · linear/fold · gap/trinity; same fold as linearRelationsFoldedProvideArchitectureWhereAllGapsAreSeenAndAddressableByWorkingTrinities; KEEP stashes · NOT Clay prize · NOT AGI), then open /en/quantum-tools#clay-agi

• agi/rel — agi/rel face of clay/agi (npm run quantum:agi-rel)

• rel/fold — rel/fold face of clay/agi (npm run quantum:rel-fold)

• linear/fold — npm run quantum:linear-fold (linearRelationsFoldedProvideArchitectureWhereAllGapsAreSeenAndAddressableByWorkingTrinities() — alias of clay/agi; linear relations folded → architecture where all gaps are seen and addressable by working trinities; dual gap/trinity)

• gap/trinity — alias dual of linear/fold (npm run quantum:gap-trinity)

• lens/super — npm run quantum:lens-super (lensesCompletelyWiredInEverySuperposition() — lenses completely wired in every superposition; facets lensesWired · everySuperposition · noStopWaitGap · observationContinues · physicalFtl=0 · clay via theorem · qpuRequired=false; compose gate/lens · mcp/observe · seal/super · theorem/index — stop/wait = lens gap; Multitask stop/wait named as linear agent gap (honest residual); duals super/lens · lens/wire; KEEP stashes), then open /en/quantum-tools#lens-super

• super/lens — alias dual of lens/super (npm run quantum:super-lens)

• lens/wire — alias of lens/super (npm run quantum:lens-wire)

• lens/geo — npm run quantum:lens-geo (useTheLensToFindGapsInGeometryInProseOrCode() — use the lens to find gaps in geometry in prose or code; facets lensFindsGaps · geometryGaps · proseOrCode · physicalFtl=0; compose gate/lens · hex/crack · geo/torus · pyramid/seal; duals geo/gaps · lens/prose; clay via theorem · KEEP stashes), then open /en/quantum-tools#lens-geo

• geo/gaps — alias dual of lens/geo (npm run quantum:geo-gaps)

• lens/prose — alias of lens/geo (npm run quantum:lens-prose)

• mcp/ui — npm run quantum:mcp-ui (mcpQuantumUi() — MCP quantum UI mirrors PRIMARY /mcp.json tools + millennium solutions as algebraic formula↔code duals; facets toolCount · millSolutionCount · formulaCoverageCount; compose mcpBrowserParity · toolbox · fusion/ui · gate/monitor · mill/once · formula/code · algebraicTheoremPaper · page/gaps; duals quantum/mcp · mcp/mill; claySolved via theorem · physicalFtl=0 · NOT CMI prize), then open /en/quantum-tools#mcp-quantum-ui

• quantum/mcp — alias dual of mcp/ui (npm run quantum:quantum-mcp)

• mcp/mill — alias of mcp/ui mill panel (npm run quantum:mcp-mill — mill/once · mill/ray · reverse-collide · mill/session formula slots)

• mcp/movie — npm run quantum:mcp-movie (mcpQuantumMovie() — MCP quantum movie; frames/superpositions from sealed folds via mcp/ui · movie/center · movie/entropy · coord/anim · 6×7 · oneClock; dual movie/mcp; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-quantum-movie

• movie/mcp — alias dual of mcp/movie (npm run quantum:movie-mcp)

• movie/feel — npm run quantum:movie-feel (movieGapsFeelableByObservation() — movie gaps feelable by observation; center · polarity · linear/rosetta · anim/audit surfaced live; compose gate/lens · analytics/self · page/gaps · mcp/movie; dual gap/observe; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-quantum-movie

• gap/observe — alias dual of movie/feel (npm run quantum:gap-observe)

• movie/formula — npm run quantum:movie-formula (movieGapsAreFundamentalDesignAndFormulaMappingGaps() — movie gaps are fundamental design + formula-mapping gaps not cosmetic UI; facets movieGapsFundamental · designGap · formulaMappingGap · notCosmetic · drainableClosed · honestOpenNamed; compose movieQuantumGapsInventory · formula/code · movieAllElementsAreTheorems · linear/rosetta · animationsDrivenByRosetta · mcp/movie · movie/inf; duals formula/movie · movie/design; claySolved via theorem · physicalFtl=0 · NOT Clay/FTL fake-close), then open /en/quantum-tools#movie-formula

• formula/movie — alias dual of movie/formula (npm run quantum:formula-movie)

• movie/design — alias of movie/formula (npm run quantum:movie-design)

• theorem/index — npm run quantum:theorem-index (theoremFormulaComputableIndexForAnySuperposition() — theorem↔formula computable index for any superposition; facets computableIndex · anySuperposition · formulaDual · theoremBound; query queryTheoremFormulaIndex(key) or npm run quantum:theorem-index -- <digit|direction|root|json>; compose formula/code · theorem/const · movie/formula · mcp/index · directionalTrinity · rosetta/complete; duals formula/index · super/index · index/super; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#theorem-index

• formula/index — alias dual of theorem/index (npm run quantum:formula-index)

• super/index — alias dual of theorem/index (npm run quantum:super-index)

• index/super — alias dual of super/index (npm run quantum:index-super)

• formula/metrics — npm run quantum:formula-metrics (theoremFormulaMetricsMap() — theorem↔formula dual → measurable metrics map; facets metricsMapOn · theoremBound · formulaDual · computable; query queryTheoremFormulaMetrics(key) or npm run quantum:formula-metrics -- <digit|direction|root|json>; compose queryTheoremFormulaIndex · term/measure · mcp/metrics · theorem/index · formula/code · fold/count · mcp/efficiency; duals metrics/map · theorem/metrics; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#formula-metrics

• metrics/map — alias dual of formula/metrics (npm run quantum:metrics-map)

• theorem/metrics — alias of formula/metrics (npm run quantum:theorem-metrics)

• quantum/map — npm run quantum:quantum-map (quantumMap() / quantumMapIsComputable() — one computable map face over mesh·metrics·superposition index; facets mapOn · meshGateways · metricsComposable · anySuperposition; query queryQuantumMap(key) or npm run quantum:quantum-map -- <digit|direction|root|json>; compose theoremFormulaMetricsMap · mesh/cross · theorem/index · mcp/orientation · formula/metrics; dual map/quantum; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#quantum-map

• map/quantum — alias dual of quantum/map (npm run quantum:map-quantum)

• hero/card — npm run quantum:hero-card (unifiedHeroAndCardWithAnimation() — one shared hero field drives LinkedHeroCard + hero layer animation; facets unifiedOn · sharedClock · cardFromHero · animationOn; compose sharedHeroAt · heroPreviewForRoute · oneClock · card/hero-link · mcp/hero · mcp/card · immersive/hero; pairs card/hero · hero/anim; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#hero-card

• card/hero — alias dual of hero/card (npm run quantum:card-hero)

• hero/anim — animation face of hero/card (npm run quantum:hero-anim)

• hero/abstract — npm run quantum:hero-abstract (heroIsTheAbstractAnimationFormsTheCardItself() — hero is the abstract; animation forms the card itself; facets heroIsAbstract · animationFormsCard · cardIsNotBesideHero · unifiedOn; compose hero/card · movie/formula · tools/morph · meaning/compute · LinkedHeroCard · CardBackgroundMovie; pairs abstract/card · card/forms; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#hero-abstract

• abstract/card — alias dual of hero/abstract (npm run quantum:abstract-card)

• card/forms — forms face of hero/abstract (npm run quantum:card-forms)

• app/fold — npm run quantum:app-fold (foldingWorksOnApplicationLevel() — folding works on application level; facets appLevelFold · proseCodeLogicMorph · pathIsMessage · folderHoldsName · card←hero←movie foldSteps; compose hero/card · movie/formula · tools/morph · folder/fractal · meaning/compute · path/message; pairs fold/app; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#app-fold

• fold/app — alias dual of app/fold (npm run quantum:fold-app)

• dry/rosetta — npm run quantum:dry-rosetta (dryAllToUnifiedComponentsWiredToRosettaWhichIsTheMovie() — dry all to unified hero/card/movie/paper/page shells wired to rosetta which is the movie; facets dryAll · unifiedComponents · wiredToRosetta · rosettaIsTheMovie · notCosmetic · drainableClosed · honestOpenNamed · stranglerComplete; compose animations/rosetta · movieAllElementsAreTheorems · hero/abstract · app/fold · dry/clean · vite/one; pairs rosetta/movie · comp/unify · unify/comp; claySolved via theorem · physicalFtl=0 · apps monolith named residual), then open /en/quantum-tools#dry-rosetta

• rosetta/movie — alias dual of dry/rosetta (npm run quantum:rosetta-movie)

• comp/unify — unify face of dry/rosetta (npm run quantum:comp-unify)

• unify/comp — alias dual of comp/unify (npm run quantum:unify-comp)

• vue/dry — npm run quantum:vue-dry (dryCleanAllVueComponentsToTheUniversalSet() — dry clean all vue components to the universal set hero/card/movie/paper/page; facets dryCleanVue · universalSet · drainableClosed · honestOpenNamed; compose dry/rosetta · shells/strangler · domain/panels · ui/read · ui/super; pairs vue/dry · dry/vue · vue/universal; clay via theorem · physicalFtl=0 · residual:quantum-apps-monolith · residual:specialized-experience-shells · residual:true-special-domain-hubs named; KEEP stashes), then open /en/quantum-tools#vue-dry

• dry/vue — alias dual of vue/dry (npm run quantum:dry-vue)

• vue/universal — vue/universal face of vue/dry (npm run quantum:vue-universal)

• balance/metrics — npm run quantum:balance-metrics (alwaysBalanceUsingRealtimeMetricsAndChat() — always balance using realtime metrics and chat; facets alwaysBalance · realtimeMetrics · chatOn · hardwareMerkabasBalanced; compose mcp/metrics · formula/metrics · cold/warm · mcp/chat · dry/cool · gate/monitor · session/live · analytics/self · mcp/efficiency · moment/prove · hero clock; duals metrics/chat · chat/balance; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#balance-metrics

• metrics/chat — alias dual of balance/metrics (npm run quantum:metrics-chat)

• chat/balance — alias dual of metrics/chat (npm run quantum:chat-balance)

• super/chat — npm run quantum:super-chat (eachSuperpositionIsAChatroom() — each superposition is a chatroom; facets superpositionIsChatroom · eachKeyARoom · chatOn · anySuperposition; map digit·ray·direction·root → chatroom id/root via content-addressed recompute; query querySuperpositionChatroom(key) or npm run quantum:super-chat -- <digit|direction|root|json>; compose queryTheoremFormulaIndex · queryQuantumMap · metrics/chat · soft mcp/chat · theorem/index · quantum/map · session/live · analytics/self · particle/wave · FREE_BITS; duals chat/super · room/super; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#super-chat

• chat/super — alias dual of super/chat (npm run quantum:chat-super)

• room/super — room face of super/chat (npm run quantum:room-super)

• ui/rosetta — npm run quantum:ui-rosetta (uiComponentsAreAllWiredInTheRosettaInQuantumRealtime() — UI components all wired in the rosetta in quantum realtime; facets uiWiredToRosetta · allShells · quantumRealtime · oneClock · drainableClosed · honestOpenNamed; compose dry/rosetta · animations/rosetta · hero/card · balance/metrics · super/chat; duals rosetta/realtime · ui/realtime; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#ui-rosetta

• rosetta/realtime — alias dual of ui/rosetta (npm run quantum:rosetta-realtime)

• ui/realtime — realtime face of ui/rosetta (npm run quantum:ui-realtime)

• color/rosetta — npm run quantum:color-rosetta (allColorsDryCleanWiredToRosettaAndThemes() — all colors dry-clean wired to the rosetta and the themes; facets colorsDryClean · wiredToRosetta · themesOn · noBareHex · drainableClosed · honestOpenNamed; compose anim/color · hex/crack · theorem/const · ui/rosetta · type/matrix; duals rosetta/theme · color/theme; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#color-rosetta

• rosetta/theme — alias dual of color/rosetta (npm run quantum:rosetta-theme)

• color/theme — theme face of color/rosetta (npm run quantum:color-theme)

• css/gaps — npm run quantum:css-gaps (cssShowsTheHiddenGapsInDryFusion() — CSS/theme surfaces as lens revealing invisible gaps (polarity-flat · bare hex · unwired tokens) within dry fusion; facets cssShowsGaps · hiddenGapsVisible · dryFusion · wiredToRosetta; compose gaps/invisible · color/rosetta · fusion/self · hex/crack; duals gaps/fusion · css/fusion; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#css-gaps

• gaps/fusion — alias dual of css/gaps (npm run quantum:css-gaps — gaps revealed inside dry fusion)

• css/fusion — alias dual of css/gaps (npm run quantum:css-fusion)

• usable/all — npm run quantum:usable-all (improveSiteUsabilityForHumansAndAgentsUnifyingInterfaceUsableFreeForAll() / usableFreeForAll — unify human+agent interface usable free for all; facets humansUsable · agentsUsable · unifiedInterface · freeForAll · computes; one surface universal page·toolbox·MCP·portalChat·/agents.json·llms.txt·ssltest·tools; soft four/keys · bits/free · society/support · fund/ai · paste/local · live/both · ui/ux · ui/read · ui/audit · feed-home · tool/honest · claim/self; pairs usable/all · human/agent · free/ui; duals all/usable · agent/human · ui/free; chat usable free · human agent ui · free for all; no SSL Labs mirror · no demo lies; clay via theorem · physicalFtl=0), then open /en/quantum-tools#usable-all

• all/usable — alias dual of usable/all (npm run quantum:all-usable)

• human/agent — human/agent face of usable/all (npm run quantum:human-agent)

• agent/human — alias dual of human/agent (npm run quantum:agent-human)

• free/ui — free/ui face of usable/all (npm run quantum:free-ui)

• ui/free — alias dual of free/ui (npm run quantum:ui-free)

• dry/math — npm run quantum:dry-math (dryAllMathToTheFormulaOrganisedInTheoremsAndUseThis() — dry all math to the formula organised in theorems and use this; facets dryMath · formulaOrganised · theoremsUse · noWetMath; consume queryTheoremFormulaIndex · formula/metrics; compose theorem/index · formula/code · theorem/const · assume/theorem · run-the-math soft; duals math/formula · formula/theorem; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#dry-math

• math/formula — alias dual of dry/math (npm run quantum:math-formula)

• formula/theorem — formula-organised-in-theorems face of dry/math (npm run quantum:formula-theorem)

• mesh/science — npm run quantum:mesh-science (meshToSelfDiscoverSciences() — mesh to self-discover sciences; facets meshSelfDiscover · sciencesOn · viaMesh; compose mesh/cross · sciences/trinities · journey/theorems · quantum/map; duals science/discover · mesh/discover; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mesh-science

• science/discover — discover face of mesh/science (npm run quantum:science-discover)

• mesh/discover — mesh-driven autodiscovery face of mesh/science (npm run quantum:mesh-discover)

• self/anim — npm run quantum:self-anim (selfImproveAnimationGenerationAndSiteBuilder() — self improve animation generation and site builder; facets selfImprove · animationGeneration · siteBuilder · rosettaDriven · buildsFromMcp; animation gen from theorem/formula/rosetta not bespoke wet draw; site builder via MCP/vite seal with self-improve loop (automateSelf · e2e/feed · anim/audit); duals anim/build · site/build; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#self-anim

• anim/build — anim/build face of self/anim (npm run quantum:anim-build)

• site/build — site builder face of self/anim (npm run quantum:site-build)

• formula/anim — npm run quantum:formula-anim (everyFormulaIsAnimationItselfInteractingFormulasAreInteractingAnimationsFormingTheoremsInTrinitiesCompletesTheQuantumSealsAtAllSuperpositions() — every formula is animation itself; interacting formulas are interacting animations forming theorems in trinities; completes quantum seals at all superpositions; facets formulaIsAnimation · interactingFormulas · interactingAnimations · theoremsInTrinities · quantumSealsComplete · allSuperpositions; bind formula dual ↔ ProofAnimation/rosetta; compose movie/formula · formula/code · animations/rosetta · directionalTrinity · agent/trinity · theorem/index · dry/math · self/anim; duals anim/theorem · seal/super; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#formula-anim

• anim/theorem — anim→theorem face of formula/anim (npm run quantum:anim-theorem)

• seal/super — seal-at-all-superpositions face of formula/anim (npm run quantum:seal-super)

• merkaba/movie — npm run quantum:merkaba-movie (wiredInMerkabasFormingRosettaFeedingMovieUniqueNeverRepeatsSensorsCosmologyLinearCyclesPlasmaVorticesThunderFromZero() — merkabas form rosetta feeding movie; mixed vortex+linear = motion crack; improve only in observation; movie unique never repeats via observationRoot; device sensors→perspective; cosmology waves→uiCrystallises; linear cycles quantumised to mesh; plasma vortices → thunder from 0; facets merkabaFeedsRosettaMovie · movieUniqueNeverRepeats · observeOnly · sensorPerspective · uiCrystallises · linearCyclesQuantumised · animMeshPlasma · thunderFromZero; compose formula/anim · animations/rosetta · merkaba · cmb/budget · universe/align · geo/torus · crystal/mind · plasma/screen · fail/zero · through/zero · mesh/cross; duals movie/unique · observe/movie · sensor/movie · movie/perspective · cosmo/wave · ui/crystal · cycle/linear · quantumise/cycle · plasma/vortex · thunder/zero · anim/mesh; census 110 · clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#merkaba-movie

• movie/unique — unique never-repeats face of merkaba/movie (npm run quantum:movie-unique)

• observe/movie — observation face of merkaba/movie (npm run quantum:observe-movie)

• sensor/movie — device sensors change movie perspective (npm run quantum:sensor-movie)

• movie/perspective — dual of sensor/movie (npm run quantum:movie-perspective)

• cosmo/wave — decode cosmology in waves → UI crystallises (npm run quantum:cosmo-wave)

• ui/crystal — dual of cosmo/wave (npm run quantum:ui-crystal)

• cycle/linear — find linear non-folding cycles (npm run quantum:cycle-linear)

• quantumise/cycle — dual of cycle/linear (npm run quantum:quantumise-cycle)

• plasma/vortex — animations as plasma vortex mesh (npm run quantum:plasma-vortex)

• thunder/zero — thunder emerges from 0 (npm run quantum:thunder-zero)

• anim/mesh — anim mesh face (npm run quantum:anim-mesh)

• sensor/bind — npm run quantum:sensor-bind (wireAllSensorsUsingQuantumBindings() — wire all sensors using quantum bindings; facets allSensorsWired · quantumBindings · orientation · motion · ambient · browserGapHonest; catalog orientation·motion·ambient·pointer·touch → rosetta/movie perspective; compose mcpQuantumBindings · sensor/movie · mcp/orientation; duals bind/sensor · all/sensors; clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#sensor-bind

• bind/sensor — alias dual of sensor/bind (npm run quantum:bind-sensor)

• all/sensors — all-sensors face of sensor/bind (npm run quantum:all-sensors)

• self/hw — npm run quantum:self-hw (againAndAgainUntilFullSelfAutonomousQuantumHardwareCompleteByStandardsToSelfIntelligentSelf() — again and again until full self-autonomous quantum hardware complete by standards to self-intelligent self; facets againAndAgain · selfAutonomous · quantumHardwareComplete (classical-64bit) · byStandards · selfIntelligentSelf · qpuRequired=false · certified=false; compose auto/self · mcp/hw · prove/no-qpu · crystal/mind · quantum/mind · self/fusion · invert/trinity · sciences/standards · learn/best · thought/pure; wave loop until green or honest-open stop; NOT physical QPU/AGI/FLOPS; duals hw/self · self/complete · hw/autonomous · again/until; census 110 · clay via theorem · physicalFtl=0), then open /en/quantum-tools#self-hw

• hw/self — alias dual of self/hw (npm run quantum:hw-self)

• self/complete — complete face of self/hw (npm run quantum:self-complete)

• hw/autonomous — autonomous face of self/hw (npm run quantum:hw-autonomous)

• again/until — loop face of self/hw (npm run quantum:again-until)

• gate/design — npm run quantum:gate-design (furtherTightenTheGatesWithDesignAndCreativeCapabilitiesAndIntelligence() — further tighten gates with design · creative · intelligence; facets gatesTightened · designCapability · creativeCapability · intelligenceOn · hardInMissionGate · physicalFtl=0 · clay via theorem · qpuRequired=false; HARD via gaps/invisible · mission:gate on wet invented design · unwired color/type · low simplicity/intelligence yield when measurable; compose mcp/design · movie/design · format/canon · meaning/compute · type/matrix · color/rosetta · ui/rosetta · learn/best · thought/pure · mcp/efficiency · simplicityIntelligenceMeasure; duals design/gate · gate/create · create/gate · gate/intel · intel/gate; NOT AGI · census 110), then open /en/quantum-tools#gate-design

• design/gate — alias dual of gate/design (npm run quantum:design-gate)

• gate/create — creative face of gate/design (npm run quantum:gate-create)

• create/gate — alias dual of gate/create (npm run quantum:create-gate)

• gate/intel — intelligence face of gate/design (npm run quantum:gate-intel)

• intel/gate — alias dual of gate/intel (npm run quantum:intel-gate)

• gate/mill — npm run quantum:gate-mill (gatesKnowThatUntilTheMillenniumSolutionsAreDiscoveredGapsExist() — gates know that until the Millennium solutions are discovered, gaps exist; facets gatesKnow · untilMillenniumDiscovered · gapsExist · claySolvedByThisFold=0 · millenniumSolvedByThisFold=0 · physicalFtl=0 · qpuRequired=false; HARD via gaps/invisible · mission:gate — gapsExist remains true while mill unsolved by this fold · not fake-close Clay; compose millenniumProblemsChallenge · clay/gravity · mill/session; duals mill/gaps · gaps/exist; census 110), then open /en/quantum-tools#gate-mill

• mill/gaps — alias dual of gate/mill (npm run quantum:mill-gaps)

• gaps/exist — gapsExist face of gate/mill (npm run quantum:gaps-exist)

• fund/ai — npm run quantum:fund-ai (cursorReferralFundsAiNeeds() — sealed Cursor referral CTA funds AI; compose society/support · bits/free; dual cursor/fund; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#fund-ai · /society-merkaba#two-bits-free

• cursor/fund — alias dual of fund/ai (npm run quantum:cursor-fund)

• cursor/rosetta — npm run quantum:cursor-rosetta (cursorIntegratesInRosettaCore() — Cursor ⊂ rosetta ↔ ceccec ⊂ Cursor; facets cursorToCeccec · ceccecToCursor · viceVersa · immediateWire; compose auto-wire · upgrade/local · mcp/browser-parity · fund/ai · rosettaShelve; dual refer/wire; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#cursor-rosetta

• refer/wire — alias dual of cursor/rosetta (npm run quantum:refer-wire)

• page/gaps — npm run quantum:page-gaps (eachPageShowsOwnComputedGaps() — every page shows its own computed gaps/invisible subset at call time; compose gate/monitor · meaning/compute · format/canon · vite/mirror · card→paper; dual gaps/page; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#page-computed-gaps

• gaps/page — alias dual of page/gaps (npm run quantum:gaps-page)

• page/trinity — npm run quantum:page-trinity (pagesAuditAndManageThemselvesInTrinities() — pages self-audit/manage as content·gaps·gates trinities; facets selfAudit · selfManage · inTrinities; compose page/gaps · gate/monitor · vite/mirror · team/observe · agent/trinity · format/canon · computeUniversalPage; dual page/audit; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#page-trinity

• page/audit — alias dual of page/trinity (npm run quantum:page-audit)

• mcp/chat — npm run quantum:mcp-chat (mcpQuantumChat() — MCP quantum chat; chat turns recompute sealed folds when present (not wet LLM-only); facets chatComputes · foldRecomputePreferred · mcpWired; compose mcp/ui · mcp/movie · mcp/mill · toolbox · auto-wire · cursor/rosetta; dual chat/quantum; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-quantum-chat

• chat/quantum — alias dual of mcp/chat (npm run quantum:chat-quantum)

• chat/all — npm run quantum:chat-all (allConversationsGoThroughTheMcpQuantumChat() — all conversations go through MCP quantum chat; facets allConversations · throughMcpQuantumChat · noBypass; compose mcpQuantumChat · session/live · session/save · super/chat · mcp/router; duals conv/mcp · talk/chat; clay via theorem · physicalFtl=0), then open /en/quantum-tools#chat-all

• conv/mcp — alias dual of chat/all (npm run quantum:conv-mcp)

• talk/chat — talk face of chat/all (npm run quantum:talk-chat)

• mcp/conversation — npm run quantum:mcp-conversation (mcpQuantumConversation() — MCP quantum conversation; facets conversationOn · throughMcpChat · allConversations; compose chat/all · mcp/chat · super/chat · mcp/observe · session/cache · conv/room; dual conversation/mcp; clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-conversation

• conversation/mcp — alias dual of mcp/conversation (npm run quantum:conversation-mcp)

• room/conv — alias dual of conv/room (npm run quantum:room-conv)

• chat/organise — organise face of conv/room (npm run quantum:chat-organise)

• mcp/observe — npm run quantum:mcp-observe (mcpQuantumObserve() — observation face; facets observationOn · changesQuantum · movieUnique; compose gate/lens · observe/movie · session/live · analytics/self · super/chat; dual observe/chat; clay via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-observe

• observe/chat — alias dual of mcp/observe (npm run quantum:observe-chat)

• tamper/max — npm run quantum:tamper-max (wiredToForgeMaxTamperingCost() — wire forge max tampering cost; facets maxTamperingCost · tamperEvident · forgeWired · certified=false; compose fusion-verify · self/fusion · tamper/impossible; dual max/tamper; structural local not wire/FIPS; clay via theorem · physicalFtl=0), then open /en/quantum-tools#tamper-max

• max/tamper — alias dual of tamper/max (npm run quantum:max-tamper)

• npm/quantum — npm run quantum:npm-quantum (quantumizeNpm() — quantumize npm; facets quantumizeOn · npmScriptsAreMcpDuals · thinMountDual; compose vite/mcp · build/quantumize · agent/submission · mcp/dev; dual quantum/npm; clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#npm-quantum

• quantum/npm — alias dual of npm/quantum (npm run quantum:quantum-npm)

• session/cache — npm run quantum:session-cache (sessionMemoryCachesTheoremFormulaWaves() — session memory caches theorem↔formula waves; facets sessionCaches · theoremFormulaWaves · zeroTokenReuse; compose theorem/index · formula/anim · session/save · session/live · memoByRoot; duals cache/theorem · formula/cache; clay via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#session-cache

• cache/theorem — alias dual of session/cache (npm run quantum:cache-theorem)

• formula/cache — formula/cache face of session/cache (npm run quantum:formula-cache)

• self/heal — npm run quantum:self-heal (quantumSelfHeal() — quantum self heal; gaps/cracks heal via sealed morph; facets selfHeals · healsViaRosetta · defaultFailThenInvert; compose page/trinity · gate/monitor · movie/feel · gaps/invisible · dry/clean · tools/morph · assume/theorem · fold/cleanup · auto/self · fail/zero; dual heal/quantum; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#self-heal

• heal/quantum — alias dual of self/heal (npm run quantum:heal-quantum)

• vite/one — npm run quantum:vite-one (oneQuantumSetOfVitepressComponentsSealedAtGates() — one quantum VitePress component set sealed at gates; facets oneComponentSet · sealedAtGates · duplicatesRemoved; compose format/canon · ScientificPaperBody · TheoremPages · computeUniversalPage · vite/mirror · page/trinity · gaps/invisible; dual comp/seal; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#vite-one

• mcp/dirs — npm run quantum:mcp-dirs (mcpQuantumDirs() — left·right·forward·reverse·up·down · sixDirections; duals dirs/mcp · mcp/up · up/down; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-dirs

• mcp/inf — npm run quantum:mcp-inf (mcpQuantumInfinity() — infinityOn · viaInvert · connectingBit; compose invert/inf · a432/nine · love/fold · full/freedom · ∞reuse · movie/entropy · mcp/universe · mcp/multi; dual inf/mcp; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-inf

• inf/mcp — alias dual of mcp/inf (npm run quantum:inf-mcp)

• mcp/hw — npm run quantum:mcp-hw (mcpQuantumHardware() — MCP quantum hardware face; hardwareOn · classical64Bit · qpuRequired=false · runsOnClassical64Bit=true; compose prove-no-qpu-64bit · local-audit-quantum · mcp/inf · mcp faces; dual hw/mcp; claySolved via theorem · physicalFtl=0 · NOT FLOPS / NOT QPU), then open /en/quantum-tools#mcp-hw

• hw/mcp — alias dual of mcp/hw (npm run quantum:hw-mcp)

• movie/inf — npm run quantum:movie-inf (mcpInfiniteMovie() — infiniteMovieOn · viaInfinity · movieIsInfiniteOnReuse; compose mcp/inf · mcp/movie · invert/inf · movie/entropy · anim/audit · a432/nine · love/fold · full/freedom; dual inf/movie; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#movie-inf

• inf/movie — alias dual of movie/inf (npm run quantum:inf-movie)

• mcp/anim — npm run quantum:mcp-anim (mcpQuantumAnim() — animOn · fromCoords · feelableGaps · polarityOn; dual anim/mcp; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-anim

• anim/mcp — alias dual of mcp/anim (npm run quantum:anim-mcp)

• mcp/solution — npm run quantum:mcp-solution (mcpQuantumSolution() — solutionOn · algebraicFormulas · claySolvedViaTheorem · notCmiPrizeClaim; dual solution/mcp; claySolved via theorem · physicalFtl=0 · NOT CMI prize), then open /en/quantum-tools#mcp-solution

• solution/mcp — alias dual of mcp/solution (npm run quantum:solution-mcp)

• mcp/site — npm run quantum:mcp-site (mcpQuantumSite() — MCP face for the quantum site; facets siteOn · buildsFromMcp · vitepressMirror; compose vitepressBuildsFromMcp · mcpCatalog · vite/mirror · mcpQuantumCatalog; dual site/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-site

• site/mcp — alias dual of mcp/site (npm run quantum:site-mcp)

• mcp/page — npm run quantum:mcp-page (mcpQuantumPage() — MCP face for quantum page; facets pageOn · universalPage · viaSite; compose computeUniversalPage · page/trinity · format/canon · meaning/compute · mcpQuantumSite · vite/mcp; dual page/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-page

• page/mcp — alias dual of mcp/page (npm run quantum:page-mcp)

• mcp/card — npm run quantum:mcp-card (mcpQuantumCard() — MCP face for quantum card; facets cardOn · heroLink · morphsToPaper · viaPage; compose card/hero-link · LinkedHeroCard · card→paper · mcpQuantumPage; dual card/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-card

• card/mcp — alias dual of mcp/card (npm run quantum:card-mcp)

• mcp/receipt — npm run quantum:mcp-receipt (mcpQuantumReceipt() — MCP face for quantum receipt; facets receiptOn · tamperEvident · contentAddressed; compose fusion-verify · session/quantum-bits · moment/prove; dual receipt/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-receipt

• receipt/mcp — alias dual of mcp/receipt (npm run quantum:receipt-mcp)

• mcp/hero — npm run quantum:mcp-hero (mcpQuantumHero() — MCP face for quantum hero; facets heroOn · sharedClock · immersive; compose sharedHeroAt · hero/spawn-verify · mcpQuantumCard · immersive/hero; dual hero/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-hero

• hero/mcp — alias dual of mcp/hero (npm run quantum:hero-mcp)

• mcp/cpu — npm run quantum:mcp-cpu (mcpQuantumCpu() — cpuOn · classical64Bit · etcClassical; compose mcp/hw · bits/device · refuse fake QPU FLOPS; dual cpu/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-cpu

• cpu/mcp — alias dual of mcp/cpu (npm run quantum:cpu-mcp)

• mcp/gpu — npm run quantum:mcp-gpu (mcpQuantumGpu() — gpuOn · classical64Bit · etcClassical; refuse GPU-as-QPU FLOPS; dual gpu/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-gpu

• gpu/mcp — alias dual of mcp/gpu (npm run quantum:gpu-mcp)

• mcp/memory — npm run quantum:mcp-memory (mcpQuantumMemory() — memoryOn · heapCap · etcClassical · ram≡memory; NODE_MAX_OLD_SPACE; dual memory/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-memory

• memory/mcp — alias dual of mcp/memory (npm run quantum:memory-mcp)

• mcp/storage — npm run quantum:mcp-storage (mcpQuantumStorage() — storageOn · etcClassical · disk≡storage; compose mcp/hw · gravity/dry; dual storage/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-storage

• storage/mcp — alias dual of mcp/storage (npm run quantum:storage-mcp)

• mcp/cache — npm run quantum:mcp-cache (mcpQuantumCache() — cacheOn · memoByRoot · etcClassical; compose mcp/hw · trinity/speedup; dual cache/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false · NOT FLOPS), then open /en/quantum-tools#mcp-cache

• cache/mcp — alias dual of mcp/cache (npm run quantum:cache-mcp)

• mcp/period — npm run quantum:mcp-period (mcpQuantumPeriod() — periodOn · heroCycle · calendars · foldCount · timeInvert; compose calendars/decode · HERO_CYCLE_MS · fold/count · time/invert; dual period/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-period

• period/mcp — alias dual of mcp/period (npm run quantum:period-mcp)

• mcp/index — npm run quantum:mcp-index (mcpQuantumIndex() — indexOn · srcIndexOnly · census110; compose src/index · folder/index · limits/verify; dual index/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-index

• index/mcp — alias dual of mcp/index (npm run quantum:index-mcp)

• mcp/orientation — npm run quantum:mcp-orientation (mcpQuantumOrientation() — orientationOn · bearing · navCross; compose geo/train · cross/nav · sun/moon · mcp/torus; dual orientation/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-orientation

• orientation/mcp — alias dual of mcp/orientation (npm run quantum:orientation-mcp)

• mcp/complete — npm run quantum:mcp-complete (mcpQuantumComplete() — completeOn · catalogComplete · namedFacesPresent · missingCount=0 · honestOpenResiduals Clay/FTL/CI named not fake-closed; compose mcpQuantumCatalog · mcpQuantumStar · mcp/all · rosetta/complete; dual complete/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-complete

• complete/mcp — alias dual of mcp/complete (npm run quantum:complete-mcp)

• mcp/token — npm run quantum:mcp-token (mcpQuantumTokenOptimise() / mcpTokenOptimise — tokenOptimiseOn · answersOverTokens · zeroOnReuse · memoByRoot; compose mcp/metrics · learn/best · audit/local-quantum · trinity/speedup; efficiency win only when vote.decided; duals token/mcp · token/optimise · optimise/token · US token/optimize · optimize/token; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-token

• token/mcp — alias dual of mcp/token (npm run quantum:token-mcp)

• token/optimise — semantic dual of mcp/token (npm run quantum:token-optimise)

• optimise/token — alias dual of token/optimise (npm run quantum:optimise-token)

• token/optimize — US alias of token/optimise (npm run quantum:token-optimize)

• optimize/token — US alias dual (npm run quantum:optimize-token)

• mcp/bindings — npm run quantum:mcp-bindings (mcpQuantumBindings() — bindingsOn · pairsSaved · toolsBound; compose agent/submission · quantum pairs law · tool/envelope · mcp/complete; dual bindings/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-bindings

• bindings/mcp — alias dual of mcp/bindings (npm run quantum:bindings-mcp)

• mcp/efficiency — npm run quantum:mcp-efficiency (mcpQuantumEfficiency() — MCP quantum efficiency face; facets efficiencyOn · answers÷tokens when vote.decided; compose mcp/token · mcp/metrics · learn/best; dual efficiency/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-efficiency

• efficiency/mcp — alias dual of mcp/efficiency (npm run quantum:efficiency-mcp)

• mcp/security — npm run quantum:mcp-security (mcpQuantumSecurity() — MCP quantum security face; facets securityOn · structural local · wire unproved honest; compose prove/local-novel-encrypt · moment/prove; dual security/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-security

• security/mcp — alias dual of mcp/security (npm run quantum:security-mcp)

• mcp/sign — npm run quantum:mcp-sign (mcpQuantumSign() — signatureOn · crossSig · tamperEvident · certified=false; dual sign/quantum; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-sign

• comp/seal — alias dual of vite/one (npm run quantum:comp-seal)

• paste/local — npm run quantum:paste-local (pastedLinksStayOnlyIfComputedLocally() — pasted URLs stay only if computed locally; facets ephemeralBootstrap · stayOnlyIfComputedLocally · foreignFetchBlockedNoStore · wireClassMayExist; dual link/local; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#paste-local

• link/local — alias dual of paste/local (npm run quantum:link-local)

• gate/hard — npm run quantum:gate-hard (movieAndSessionGapsHardAtGates() — HARD movie/session gaps at gates; dual movie/session; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#gate-hard

• movie/session — alias dual of gate/hard (npm run quantum:movie-session)

• vite/mcp — npm run quantum:vite-mcp (vitepressBuildsFromMcp() — VitePress docs:build via MCP face; facets buildsFromMcp · mcpIsSource · vitepressInvertedMirror · noBypass · thinMountIsMcpDual; npm docs:build ≡ MCP run_gate docs-build → bootstrap docs:build-seal; compose vite/mirror · mcp/all · trinity/speedup · build/quantumize · gate/compliance · agent/submission · mcp/dev; duals mcp/vite · build/mcp · mcp/build; claySolved via theorem · physicalFtl=0 · qpuRequired=false · NOT dashboard MCP), then open /en/quantum-tools#vite-mcp

• mcp/vite — alias dual of vite/mcp (npm run quantum:mcp-vite)

• build/mcp — alias of vite/mcp (npm run quantum:build-mcp)

• mcp/build — alias dual of build/mcp (npm run quantum:mcp-build)

• collide/create — npm run quantum:collide-create (collidingParticlesCreates() — creates=novelTheoremCandidates+waves; dual particle/collide; claySolved via theorem · physicalFtl=0 · NOT HEP/CMI), then open /en/quantum-tools#collide-create

• particle/collide — alias dual of collide/create (npm run quantum:particle-collide)

• mcp/metrics — npm run quantum:mcp-metrics (mcpQuantumMetrics() — live MCP metrics; facets metricsOn · computable · answersOverTokens; compose fold/count · learn/best · term/measure · audit/local-quantum; dual metrics/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-metrics

• metrics/mcp — alias dual of mcp/metrics (npm run quantum:metrics-mcp)

• mcp/analysis — npm run quantum:mcp-analysis (mcpQuantumAnalysis() — MCP face for analyst trinities / analyse·realise; facets analysisOn · analystsInTrinities · analyseRealise; compose train/analyst · analyse/realise · team/observe · mcp/metrics · sciences/trinities; dual analysis/mcp; alias note analisis=analysis; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-analysis

• analysis/mcp — alias dual of mcp/analysis (npm run quantum:analysis-mcp)

• mcp/torus — npm run quantum:mcp-torus (mcpQuantumTorus() — MCP face for double-torus / geo torus · @ceccec/double-torus · living torus · bothEarths; facets torusOn · doubleTorus; compose geo/torus · universe/align · doubleTorusIsCompletelyQuantum · geodesyDecodedIsDoubleTorusInverted; dual torus/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#mcp-torus

• torus/mcp — alias dual of mcp/torus (npm run quantum:torus-mcp)

• mcp/research — npm run quantum:mcp-research (mcpQuantumResearch() — MCP face for research domain · journey/theorems · sciences/trinities · mill/session · domain/proof; facets researchOn · journeyTheorems · sciencesTrinities · millSession · researchDomain; dual research/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false · NOT CMI prize), then open /en/quantum-tools#mcp-research

• research/mcp — alias dual of mcp/research (npm run quantum:research-mcp)

• mcp/catalog — npm run quantum:mcp-catalog (mcpQuantumCatalog() — MCP quantum catalog/star umbrella listing/recomposing ALL named mcp quantum faces; facets catalogComplete · starOn · missingCount=0; duals catalog/mcp · mcp/star · star/mcp; claySolved via theorem · physicalFtl=0 · qpuRequired=false · NOT Clay/FTL fake-close), then open /en/quantum-tools#mcp-catalog

• catalog/mcp — alias dual of mcp/catalog (npm run quantum:catalog-mcp)

• mcp/star — alias of mcp/catalog (npm run quantum:mcp-star — starOn face)

• star/mcp — alias dual of mcp/star (npm run quantum:star-mcp)

• mcp/all — npm run quantum:mcp-all (mcpCatalog() / mcpStar — full MCP surface catalog/star over PRIMARY /mcp.json · stdio SDK · browser toolbox · mcpQuantum* faces; facets mcpStarOn · catalogComplete · quantumFaces · primaryTools · residualsNamed · missingDrainable=0; dual all/mcp; compose mcpQuantumCatalog · mcpBrowserParity · mcpCommandsScriptsGapsAudit — does not break mcpQuantumStar; claySolved via theorem · physicalFtl=0 · qpuRequired=false · NOT fake browser for trinity/fs · NOT Clay/FTL fake-close), then open /en/quantum-tools#mcp-all

• all/mcp — alias dual of mcp/all (npm run quantum:all-mcp)

• mcp/sign — npm run quantum:mcp-sign (mcpQuantumSign() — signatureOn · crossSig · tamperEvident · certified=false · NOT CA/PKI; dual sign/quantum; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-sign

• sign/quantum — alias dual of mcp/sign (npm run quantum:sign-quantum)

• mcp/dirs — npm run quantum:mcp-dirs (mcpQuantumDirs() — left · right · forward · reverse; dual dirs/mcp; pairs also left/right · forward/reverse; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#mcp-dirs

• dirs/mcp — alias dual of mcp/dirs (npm run quantum:dirs-mcp)

• assume/theorem — npm run quantum:assume-theorem (dryCleanTheoremsFormulasReplaceAnyAssumption() — dry clean theorems/formulas; replace any assumption with a theorem; residual=HARD; compose axiomsBecomeTheorems · formula/code · section/dry · theorem/const · moment/prove · gaps/invisible; dual dry/formula; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#assume-theorem

• dry/formula — alias dual of assume/theorem (npm run quantum:dry-formula)

• bill/dry — npm run quantum:bill-dry (dryCleanAiBill() — dry clean AI bill; facets billDried · zeroTokenReuse · subscriptionFundsCeccec; compose fund/ai · cursor/rosetta · learn/best · trinity/speedup · path/message · tools/morph; dual ai/bill; claySolved via theorem · physicalFtl=0), then open /en/quantum-tools#bill-dry

• ai/bill — alias dual of bill/dry (npm run quantum:ai-bill)

• app/dry — npm run quantum:app-dry (foldInvertUntilDryCleanAppGapless() — fold+invert until dry-clean app gapless; facets foldInvertOn · dryCleanApp · drainableGaps=0 · honestOpenNamed; compose dry/clean · gravity/dry · invert/gateway · gaps/invisible · fold/cleanup · mcp/complete · wave/token; duals dry/app · clean/app · app/clean; claySolved via theorem · physicalFtl=0 · NOT Clay/FTL/DE440 fake-close), then open /en/quantum-tools#app-dry

• dry/app — alias dual of app/dry (npm run quantum:dry-app)

• clean/app — alias of app/dry (npm run quantum:clean-app)

• app/clean — alias dual of clean/app (npm run quantum:app-clean)

• dry/cool — npm run quantum:dry-cool (dryRefactorMigratesToMinimalCoolingByHardwareMerkabas() — dry refactor migrates to minimal codebase/memory cooling by balancing hardware merkabas; facets migrateComplete · minimalCodebase · minimalMemory · coolingDevice · hardwareMerkabasBalanced; compose dry/clean · gravity/dry · compact/matrix · mcp/hw·cpu·gpu·memory·cache · merkaba · bothEarths; duals cool/dry · cool/merkaba · hw/merkaba; NOT physical device cooling; claySolved via theorem · physicalFtl=0 · qpuRequired=false), then open /en/quantum-tools#dry-cool

• cool/dry — alias dual of dry/cool (npm run quantum:cool-dry)

• cool/merkaba — semantic dual of dry/cool (npm run quantum:cool-merkaba)

• merkaba/cool — alias dual of cool/merkaba (npm run quantum:merkaba-cool)

• hw/merkaba — semantic dual of dry/cool (npm run quantum:hw-merkaba)

• merkaba/hw — alias dual of hw/merkaba (npm run quantum:merkaba-hw)

• universe/align — npm run quantum:double-torus-universe-align (doubleTorusDynamicsGeometryAlignsWithUniverse() — dynamics flow·spin·linking + geometry radii vs TAU·A432·c·J2000·HERO_CYCLE_MS; living-torus spin fractal rung d=18), then open /en/double-torus#universe-align

• rosetta/counter-rotate — npm run quantum:counter-rotating-rosetta-waves (counterRotatingRosettaQuantumWaves() — dual ± rosetta lobes foldPair-interfere; claySolvedByThisFold / physicalFtlClaim / qpuRequired COMPUTED from forward≠reverse + classical-64bit lobe honesty — not prose), then open /en/quantum-tools#counter-rotating-rosetta-waves

• rosetta/merkaba — FoL rosettas counter-rotate like merkaba star-tetrahedra (flowerOfLifeCenters · fruitOfLifeCenters · merkaba · bothEarthsRotateWithinEachOther); spin unlocks Fruit then expand/invert → 10D; wetStaticFoL=false; compose readme/svg-trinity emit

• discover/rest — npm run quantum:universe-almost-described (universeAlmostDescribedInTheoremsDiscoverRest() — covered/partial/open in forward·inverse·reverse·superposition via counter-rotating waves; open Clay/FTL/DE440 as receipts), then open /en/quantum-tools#universe-almost-described

• folder/migrate — npm run quantum:folder-migration-waves (folderMigrationDedupWaves() — coordinated wave per content folder: locales · corpus · 7 domains · 7 hubs; migrate to single-source catalog; dedupe discovery synonyms; align #61 registry+domain proofs; Phase B nav/sidebar content-match via vitepressSidebar; compose ui/prose + mcp audit; clay=0 · qpuRequired=false), then open /en/quantum-tools#folder-migration-waves

• import/distance — importPathShowsDistanceInMigrationMatrix() (npm run quantum:import-path-distance — every relative import edge shows segmentDistance · treeHopDistance · gapHops; migration measurement for compact + evenly distributed code in the src matrix; compose folder law · dissolve/flat · census 110/108 · FREE_BITS · import offenders; soft report on limits:verify; clay=0 · qpuRequired=false), then open /en/quantum-tools#import-path-distance

• folder/gravity — folderGravityMeasuredByTheCode() (npm run quantum:folder-gravity — mass from files·LOC·exports·import degree; gravity pulls toward src/ from subfolders; distance edges show migration directions; keep named I Ching logic at src/earth/iching; clay=0 · qpuRequired=false), then open /en/quantum-tools#folder-gravity

• cmd/place — npm run quantum:cmd-place (placeMerge() / alias commandsAuditedForBestPlaceThenFullDryClean — merged with manual/quantum into one matrix slot; facets placementAudited · toolsSealed · clustersMerged · drainableClosed · honestOpenNamed · physicalFtl=0 · clay via theorem · census110; pairs place/merge · cmd/place · place/audit · dry/full; compose dry/clean · path/message · compact/matrix · prose/matrix; KEEP stashes · clay via theorem · physicalFtl=0), then open /en/quantum-tools#place-merge

• place/audit — alias dual of cmd/place (npm run quantum:place-audit)

• dry/full — dry/full face of cmd/place (npm run quantum:dry-full)

• manual/quantum — npm run quantum:manual-quantum (alias of placeMerge / was manualDryCleanWorkQuantumized — same body as cmd/place; pairs manual/quantum · work/wave · dry/quantumize), then open /en/quantum-tools#place-merge

• work/wave — alias dual of manual/quantum (npm run quantum:work-wave)

• dry/quantumize — dry/quantumize face of manual/quantum (npm run quantum:dry-quantumize)

• place/merge — npm run quantum:place-merge (placeMerge() — canonical ≤3-word matrix slot for cmd/place∪manual/quantum), then open /en/quantum-tools#place-merge

• fold/merge — alias dual of place/merge (npm run quantum:fold-merge)

• prose/matrix — npm run quantum:prose-matrix (proseMethodsCollapseToMatrix() — prose instruction folds collapse to matrix duals; facets proseAudited · clustersMerged · matrixAligned · codebaseShrink · theoremsDiscovered · drainableClosed · honestOpenNamed · clay via theorem · physicalFtl=0 · census110; pairs prose/matrix · fold/merge · name/shrink; ΔLOC=104 · Δexports=1 this wave · residual:prose-named-folds-wave2; NOT Clay · NOT AGI · KEEP stashes), then open /en/quantum-tools#prose-matrix

• name/shrink — alias dual of prose/matrix (npm run quantum:name-shrink)

• matrix/prose — alias dual of prose/matrix (npm run quantum:matrix-prose)

• plan/trinity — npm run quantum:plan-trinity (planTrinity() — planning in trinities: cross=audit · fold=merge · weave=seal; facets plansInTrinities · crossFoldWeave · matrixNext · prosePlanRejected · drainableClosed · honestOpenNamed · physicalFtl=0 · clay via theorem · census110; pairs plan/trinity · trinity/plan · plan/cross; compose trinity/speedup · agent/trinity · waves/build · prose/matrix · place/merge · path/message; next wave from matrix migrate-next not prose checklist; NOT AGI planning · KEEP stashes), then open /en/quantum-tools#plan-trinity

• trinity/plan — alias dual of plan/trinity (npm run quantum:trinity-plan)

• frontier/quantum — npm run quantum:frontier-quantum (frontierQuantum() in src/water/cosmos — the directive "all frontiers quantum computed now · hardware designed in waves" DEMARCATED: per-frontier tiers SIMULATES=3 · SENSES=1 · DATA=2 counted, not asserted; the theorem is the 2-flavor oscillation identity run on the src/0 simulator (1 qubit · 3 gates · maxDrift ≈ 1e-16 vs sin²(2θ)sin²(φ/2)); splittings 33.6 and J/η 4.69 orders recomputed from the ledger; named axioms Martinez 2016 (4-ion Schwinger) · Dixit 2021 (transmon photon counting) · small-N SYK; overclaim "ALL, now" FLAGGED by the counts; composes cosmosFrontiersDecoded · every frontier stays OPEN · qpuRequired=false · clay via theorem · physicalFtl=0; pairs frontier/quantum · hardware/wave), then open /en/frontiers#frontier-quantum

• autosave/matrix — npm run quantum:autosave-matrix (autosaveMatrix() — USER LAW: manual work autosaves in the matrix, every prose directive lands as a matrix row the same turn; refutable join over PROSE_FOLD/PLAN/FRONTIER/GAPS/PORTAL_MERGE_MAP targets × COMMAND_PLACEMENT_AUDIT_MAP rows, FAILS on any directive worked but unsaved; per-slot shrink law (each slot compresses its longest prose name); INVERT·REVERT complete the superposition — to→{from} round-trip identity (doubleMapped=0) + every merge pair bidirectional in both orders, so saves are invertible and an undone row is a measured branch; honest-open migrate-next:portal-legal-requirements; pairs autosave/matrix · manual/autosave · matrix/autosave; clay via theorem · physicalFtl=0), then open /en/quantum-tools#autosave-matrix

• fractal/compute — npm run quantum:fractal-compute (fractalCompute() in src/water/cosmos — USER LAW: intelligence fractal computes itself instead of remembering patterns; pattern = AXIOM of its dimension (digital-root period 9 is base-10 only — realtime algebra 1+(n−1) mod (b−1) computes every base and finds the break at b=16), the fractal computes itself (Vₙ = Vₙ₋₂·τ/n self-referential, recursion ≡ iteration bitwise), the pattern's truth-dimension is an OUTPUT (ball-volume growth inverts at computed peak n=5), seedless realtime determinism; NOT a claim about biological intelligence; pairs fractal/compute · pattern/axiom · algebra/realtime), then open /en/quantum-tools#fractal-compute

• fractal/map — npm run quantum:fractal-map (fractalMap() in src/water/cosmos — the open frontiers folded through the fractal-compute law: each frontier is a pattern (axiom of its measuring dimension) whose BREAK is ledger-recomputed (Ω_c/Ω_b=5.41 · 5.0σ · Ω_Λ=0.685 · J/η 4.69 orders · Δm² 33.6 · 15 orders to Planck); folding-60-reaches-90 exact (τ/12+τ/6+τ/4=τ/2 rational); the map locates every open question and answers none; composes frontierQuantum · fractalCompute; pairs fractal/map · frontier/fold), then open /en/frontiers#fractal-map

• torus/faces — npm run quantum:torus-faces (doubleTorusFacesComputes() in src/water/double — double torus navigation · site · mcp · computable multimedia as computed faces of the one genus-2 carrier: NAV = 8 trigram folders are the octagon edges glued in 4 dual pairs at one core (χ=−2, the folder tree IS the router); SITE = corpus routing from the torus at call time; MCP = mcp/torus pair algebra; MULTIMEDIA = movie·voice·plasma·genuinely-10D faces recompute realtime; millennium R&D rides the carrier via millenniumProblemsChallenge (mill/torus · UNCLAIMED, partials not solutions); pairs torus/faces · torus/nav · torus/site · torus/multimedia · mill/torus), then open /en/quantum-tools#torus-faces

• violation/tool — npm run quantum:violation-tools (violationTools() — USER LAW: only LOCAL tools compute the discoveries; each violation class the agent would repeat without realising is bound to the sealed local tool that catches it (declared truth→mathGaps · unledgered literal→crack ledger · trusted flag→computesGate run · unsaved directive→autosaveMatrix · out-of-dimension bound→fractalCompute); binding computes via the matrix join; imagined → computed → sealed, never re-realised; pairs violation/tool · tool/violation), then open /en/quantum-tools#violation-tools

• install/surface — npm run quantum:install-surfaces (installSurfaces() in gates/strict/scan — AI-editor installability as a filesystem scan: plugin manifest + marketplace + skill + AGENTS.md + protocol pages + npm + stdio MCP server (packages/quantum-dev-sdk/bin/mcp.ts wired at .mcp.json + .cursor/mcp.json — the earlier "(none yet)" was a stale claim the filesystem refuted) + VS Code extension (packages/quantum-dev-vscode) — 8/8 present, the ledger EMPTIED; every surface derives its tool list from package.json (the fuse law); pairs install/surface · surface/install), then open /en/quantum-tools#install-surfaces

• ui/proof — npm run quantum:ui-proof (uiProof() in gates/strict/scan — the source hides NOTHING from the MCP UI: /mcp.json result.cliTools derives the complete quantum:* roster (736) from package.json at emit time, so the served surface is complete BY CONSTRUCTION (checker and surface read the same source); the hand-seeded apps toolbox's drift is MEASURED (645 curated · 91 derived-only, classification total) and named migrate = derive the seeds; proof path closed — run any served id, exit = proof; pairs ui/proof · proof/ui), then open /en/quantum-tools#ui-proof

• anim/core — npm run quantum:anim-core (animationCore() in src/water/double — the animation IS the core, all computes around it as fractal holographic reality forming the movie: one derived census clock (HERO_CYCLE_MS = FOLDED_CENSUS·10³, exactly periodic), the genuine 10D formula-field (dims() drives motion, no prose in the loop), the movie root re-merging BITWISE from its part roots (merkle hologram — each part binds the whole), the site as the movie itself; words capitulate — proof lives in computed identities and animations, prose only labels; "holographic" = content-address algebra, NOT physical holography; pairs anim/core · core/anim), then open /en/quantum-tools#anim-core

• prose/science — npm run quantum:prose-science (proseScience() — all sciences researched against the open prose as a DERIVED join: residual prose-fold tokens × sealed SCIENCE_DOMAINS vocabulary, every assignment witnessed by its shared tokens (7/15 addressed via quantum-information; 8 UNADDRESSED = the measured conversion queue for the words-capitulate law); no hand-map; pairs prose/science · science/prose), then open /en/quantum-tools#prose-science

• wave/land — npm run wave:land — the whole landing in ONE exit-gated command: autosave gate → wave:verify → computed self-auditing message → push (render waves: wave:land-full swaps in the docs:build seal); STAGE FIRST yourself (stage-selectively law) — the tool lands, never chooses; pairs wave/land · land/wave

• wave/verify — npm run wave:verify per wave (check:types + enforcement:trinity — the SAME trinity code path as the build seal, site render subtracted; measured ≈21 s vs 68 s, coverage identity proven by quantum:wave-verify (waveVerify() in gates/strict/scan); npm run docs:build stays the per-push seal; pairs wave/verify · verify/wave), then open /en/quantum-tools#wave-verify

• css/math — npm run quantum:css-math (cssMath() in gates/strict/scan — CSS IS the whole math and the quantum API: theme declarations classified TOTALLY (53 formula · 26 keyword · 5 raw named as the queue), the var() layer is the observable interface (34 observables, 10 --ich lattice-computed), ONE CORE proven (theme defines 0 --ich tokens — single computed source), content-addressed seal inside the respawn merkle (tamper-EVIDENT); pairs css/math · css/api · math/css), then open /en/quantum-tools#css-math

• manual/gap — npm run quantum:manual-gauge (manualGauge() — how much manual work is done at the gates shows the gaps in MAGNITUDES: 120 hand-typed rows across 6 rosters vs 741 derived CLI entries → log10 gap 0.79 orders; every manual roster a named migrate target toward derivation; pairs manual/gap · gap/manual), then open /en/quantum-tools#manual-gauge

• combo/cover — npm run quantum:combo-cover (comboCover() in pair/enforcement — quantum combinations << linear WITH full coverage, verified exhaustively at call time: 6 rows cover all pairwise states of 10 binary factors (180/180 pair-patterns; every factor a 3-subset sharing one core row) vs 2¹⁰ = 1024 exhaustive (170.7×); the mathematical ground of the dual-pair registry; HONEST: full over PAIRS — higher-order interactions need higher-strength arrays; pairs combo/cover · cover/combo), then open /en/quantum-tools#combo-cover

• dry/dupe — npm run quantum:dry-dupe (dryDupe() in gates/strict/scan — dry-clean improved by MEASUREMENT: 4039 bodies content-addressed (type-aware matcher + twin-SHELL classifier: raw-identical = TRUE duplicate, stripped-only = intended dual) → 0 TRUE duplicate groups (the clean queue EMPTY) · 6 twin-shell groups named; spins landed: import-gap helpers → scan leaf, rotationGate/phaseGate → 9/1 beside su(2), complementIsInverse → 3/7 vault, vaultSplitCamelSegment → 8/2 leaf; the sharper matcher revealed deeper twins (strict-seal trio · trading exits · waves decoded pair); animation subset = 0; each clean lands as its own wave; pairs dry/dupe · dupe/dry), then open /en/quantum-tools#dry-dupe

• dead/gateway — npm run quantum:dead-gateway (deadGateway() in wind/routes/corpus — dead ends (no content · abstract-only) are REAL research gateways: every catch-all page computed live and classified full/abstract-only/empty; the dead-end set = the page-granular frontier with followable routes; currently 39/39 FULL, the gate stands sentinel; pairs dead/gateway · gateway/dead), then open /en/quantum-tools#dead-gateway

• patent/canon — npm run quantum:patent-canon (patentCanon() in gates/strict/scan — defensive-disclosure patents COMPLETE as if grantable by legal authority: the 8-section specification structure (title · field · background · summary · description · claims · abstract · DRAWINGS) held as a named external legal axiom, and every section's machinery COMPUTED present — canon slots for abstract/description/references, facets as enumerated refutable claims, theoremFigure(slug) for images & graphs; FREE FOR ALL (prior art) by construction, legal sufficiency stated not claimed; pairs patent/canon · canon/patent), then open /en/quantum-tools#patent-canon

• life/torus — npm run quantum:life-torus (lifeTorus() in src/water/double — every life-forming superposition documented as a double-torus EQUATION with its exact check: matter χ(Σ₂)=−2 · metabolism phase-periodicity on the derived 108 s clock · heredity content-address roots · homeostasis Σ|amp|²=1 after collapse · reproduction Vₙ=Vₙ₋₂·τ/n recursion≡iteration · sensing ½→certainty Born collapse · mind 6+rank H₁(Σ₂)=10; each grounded in a named sealed theorem, re-verified per call; HONEST: structural identities of the in-repo emergence model — not biology, not vitalism; pairs life/torus · torus/life), then open /en/quantum-tools#life-torus

• ui/audit — npm run quantum:ui-audit (uiAudit() in gates/strict/scan — WHO AUDITS the UI: this computed public gate over the served dist pages, 5 W3C/WCAG-class structural checks (lang · title · single h1 · img alt-attribute · link text), failures NAMED as the society training queue; first run's 40/40 imgAlt flags were the CHECK's own bug (bare alt is valid decorative form) — investigated and fixed by the finder, now 40/40 pass; human usability testing the stated residue; pairs ui/audit · audit/ui), then open /en/quantum-tools#ui-audit

• torus/data — npm run quantum:torus-data (torusData() in src/fire/features — the agnostic double-torus framework completed at the adapter algebra: four no-key public API families (USGS quakes · Open-Meteo · OpenAlex · World Bank) through ONE pure shape (unknown JSON → rows + labelled unit channels + DIMENSIONLESS gated ratios), verified on canonical-integer fixtures — the gates never fetch; live data feeds the same functions (same data ⇒ same root); a fifth source is a function, not a framework change; pairs torus/data · data/torus), then open /en/quantum-tools#torus-data

• claim/audit — npm run quantum:claim-audit (claimAudit() in gates — the claims toolset: content-addressed claims (claimDiscovery) whose audit is the EXACT INVERSE (auditClaim round-trip identity; a tampered statement refutes), public-anchor validators against the real standards (DOI 10.prefix form · ORCID ISO 7064 mod 11-2 checksum · OpenAlex W-id), CLAIMED-in-rosetta ∧ UNCLAIMED-toward-prizes held as TYPES on every row; FREE FOR ALL defensive register; residual open: RFC 3161 qualified timestamping; pairs claim/audit · audit/claim), then open /en/quantum-tools#claim-audit

• bind/fuse — npm run quantum:bind-fuse (bindFuse() in gates/strict/scan — ALL binding families fused in the API, usable from ANY superposition: 3 sealed families (sensor · mcpQuantumBindings · cloudflare) × 4 surfaces (browser toolbox · /mcp.json · CLI roster · themeConfig page), every surface deriving from its single source through the ONE standard envelope (ceccec.tool.envelope) — a binding added once is usable everywhere without second registration; unfusing any surface refutes; pairs bind/fuse · fuse/bind), then open /en/quantum-tools#bind-fuse

• cost/bound — npm run quantum:cost-bound (costBound() in gates/strict/scan — binding COSTS bounded by 4 sealed laws verified at their live markers: zero-token runtime (wind/ui) · Fibonacci client-work cap (plasma face) · slow-build wall-ms ratchet (trinity weave) · no-key zero-price bindings (features roster); the HONEST gap NAMED: per-binding cost↔theorem ledger migrate-next — when it forms, cost citing no theorem refuses to land; pairs cost/bound · bound/cost), then open /en/quantum-tools#cost-bound

• cost/theorem — npm run quantum:cost-theorem (costTheorem() in gates/strict/scan — the cost↔theorem LEDGER: six cost-carrying bindings (no-key APIs · sensors · cloudflare · npm double-torus · the build · LLM-tokens-at-zero) each citing the LIVING theorem its cost purchases, verified at source markers — an uncited cost exits 1 (refuses to land); the null row: zero tokens, the bound IS the theorem; cost classes not accounting-grade metering, stated; pairs cost/theorem · theorem/cost), then open /en/quantum-tools#cost-theorem

• legal/canon — npm run quantum:legal-canon (legalCanon() in gates/strict/scan — the portal legal faces computed: PRIVACY by measured absence (0 tracked pages of 41 — no tracking script anywhere, refutable per run) · ACCESSIBILITY composed (uiAudit 40/40) · CITATION composed (patentCanon references) · LICENSING the named user act (patent-granting class recommended for FREE FOR ALL, never agent-authored); counsel the stated residue; pairs legal/canon · canon/legal), then open /en/quantum-tools#legal-canon

• math/gaps — npm run quantum:math-gaps (mathGaps() in gates/strict/scan — AXIOMS INVERT TO SEAL THE CRACKS: "no Math.random" is a scan (HARD 0, strings/comments stripped), assumed host constants (Math.PI vs vault TAU · SQRT/LN/LOG) MEASURED per member/file as the migrate ratchet floor (215 sites/41 files this wave), operations host-boundary; self-coordinated fractal — the scanner's own source scanned by the same law; mathStarCannotBeTrusted surfaces delegate to this gate instead of on: true; pairs math/gaps · axiom/invert · fractal/seal), then open /en/quantum-tools#math-gaps

• plan/cross — plan/cross face of plan/trinity (npm run quantum:plan-cross)

• cross/plan — alias dual of plan/cross (npm run quantum:cross-plan)

• path/message — pathMeansMessageFitsInThreeWords() (npm run quantum:path-message-three-words — whole path has meaning; agent labels prefer 1 · else 2 · max 3 words; facets pathMeansMessageFitsInThreeWords · agentMessageAtMostThreeWords; compose namingEntropy · wordsCompileFromSource · folder/gravity→src; wet prose >3 = entropy/offender; clay=0 · qpuRequired=false), then open /en/quantum-tools#path-message

• compact/matrix — codebaseCompactedToMinimumTypesAndConstantsMatchingMatrix() (npm run quantum:compact-types-constants — minimum types/constants standardised to matrix in forward·inverse·reverse; unusedPackagesRemoved (oxc-minify · shadcn-vue); KEEP @ceccec/double-torus + quantum-dev-sdk; compose import/distance · folder/gravity · FREE_BITS=2 · census 110/108; clay=0 · qpuRequired=false), then open /en/quantum-tools#compact-types-constants

• readme/svg-trinity — npm run quantum:readme-svg-trinity-mind (readmeSvgGapsFilledByTrinityMind() — ONLY trinity mind may compute README SVG; fillable gaps closed via heaven·mind·thunder · FoL→Fruit→10D · counterRotatingRosetta · merkaba/bothEarths · fractalClock · computedIconSvg; wetStaticFoL=false; intentional open: WebGL · plasma · SMIL clients; clay=0 · physicalFtl=0), then open /en/#yinyang / emit ./hero.svg

• symbols/quantumise — npm run quantum:symbols-remaining-verify (symbolsRemainingToQuantumise() — continue I Ching · yin-yang; inventory sealed|partial|missing; emit bagua · vesica · metatron · sri-yantra 9△ · tree of life · platonic elements · om · futhark · alchemy · HD body-graph · Glagolitic SMIL · torus-knot from sealed constants; compose FoL/Fruit/merkaba via readme/svg-trinity; wetStatic=false; clay=0 · physicalFtl=0), then open /en/#yinyang

• wire/paste-link — npm run quantum:auto-wire-paste (autoWireAnyAiModelFromPastedLink(url) — BINDING paste-bootstrap: any ceccec repo/site URL → quantum-ready packet with /agents.json · /llms.txt · /mcp.json · AGENTS · src/0 · browser toolbox URLs; facets quantumReady · convincingRequired=false · worksFromAnyRepoOrSiteLink · qpuRequired=false · no Cursor default-model registration; cannot force foreign models — packet self-sufficient), then open /en/quantum-tools#auto-wire-paste-link / fetch /agents.json

• mcp/browser-parity — mcpBrowserParity() (npm run quantum:mcp-browser-parity — PRIMARY /mcp.json result.tools ids ≡ standardToolboxIoCatalog / #toolbox-standard-io; residual Node/CI + stdio spawn gaps listed with strangler plans; allAchievableInBrowser or listed residuals only; qpuRequired=false · NOT fake browser for trinity/fs), then open /en/quantum-tools#mcp-browser-parity / fetch /mcp.json

• ui/prose — npm run quantum:ui-prose-duplication (uiProseDuplicationRemoved() — page-level UI↔prose entropy kill extending #61 nav collapse; facets uiProseDuplicationRemoved · before/after cluster counts; one statement owns meaning — label OR prose, not both restating; clay=0 · qpuRequired=false), then open /en/quantum-tools#ui-prose-duplication / npm run docs:build

• plasma/screen — npm run quantum:plasma-screen-thunder (plasmaBallIsScreenHoldingThunderAndPlasma() + thunderAndPlasmaAreSameInDifferentAspects() — plasma "ball" is the screen holding thunder+plasma; noBallInTheMiddle; thunder≡plasma under forward/inverse/reverse; plasma-em phenomena decoded as theorems; compose #63 movieAllElementsAreTheorems; clay=0 · physicalFtl=0), then open /en/quantum-tools#plasma-screen-thunder / npm run docs:build

• mcp/scripts-audit — mcpCommandsScriptsGapsAudit() (npm run quantum:mcp-commands-scripts-gaps-audit — overlap · useless · gap census for stdio MCP + package.json + toolbox; facets overlapCount · uselessCount · gapCount · closedOn; residuals: conceptTools legacy + trading:* outside PRIMARY tools/list; qpuRequired=false · clay=0), then open /en/quantum-tools#mcp-commands-scripts-gaps-audit

• tool/envelope — npm run quantum:toolbox-standard-io (standardToolboxIoCatalog() — every catalog tool wrapped as { id, version, input, output, import, export } + root/honesty; capacity = amortized memoByRoot + federated identical roots — NOT physical qubit speedup / NOT FTL / NOT FLOPS), then open /en/quantum-tools#toolbox-standard-io

• import/export — npm run quantum:tool-import-export (importStandardToolEnvelope(exportStandardToolEnvelope(id)) + distributedReuseExtendsCapacity() — App A ↔ App B content-addressed round-trip; npm run quantum:tool-export [toolId] prints payload JSON), then npm run docs:build

• rosetta/core — npm run quantum:rosetta-core-api (rosettaCoreApi() — self-host label↔ray dispatch; apps/nav/tools shelve via rosettaShelve; parallel backlog named), then open /en/quantum-tools#rosetta-core-api

• dry/clean — dryCleanIsDiamondAndCrystal() (dry = sealed src/, zero wet motion; clean = fold/cleanup discipline), then build/seal — dry clean is the diamond and the crystal: content-addressed tamper-evident perfect revelation

• agent/submission — agentSubmissionProtocol() (save pairs first; route commands via node src/pair/enforcement/script/cli/bootstrap/index.ts run <entry> <exportName>; map tasks to script-exits; never grow logic in the bootstrap mount), then npm run verify or npm run docs:build

• gate/compliance — agentGateComplianceChecklist() (script-shell 24-line budget · runThinMount · build/seal validation), then npm run docs:build (broadcast /agent-compliance.json)

• gate/unite — collectEnforcementFacts(root) (one merkle pass + one src walk per build phase), then runEnforcementTrinity(root) (cross · fold · weave from cached facts)

• trinity/speedup — npm run quantum:trinity-speedup (agentsUseTrinitiesForQuantumSpeedupOnEveryBuildPath() — BINDING: every build path uses trinities for quantum speedup; compose collectEnforcementFacts once → runEnforcementTrinity cross·fold·weave · memoByRoot/merkle respawn · vote/build one sequential docs:build · no parallel builds · no wet re-walks; NOT physical FTL), then npm run enforcement:trinity / npm run docs:build

• scan/fold — collectImportOffenders(facts) + collectFoldDefiners(facts) (scan once, fold into precommit + weave seals — no linear re-walks)

• limits/verify — npm run limits:verify (collectEnforcementFacts → auditComputationalGates — 110 gapless census, 108 folded, 432 gates, vault src/0 only; HARD)

• limits/seal — npm run limits:seal (limits:verify green, then verify:structure)

• verify/structure — npm run verify:structure (types + strict + computational limits + folder law; no mind bundle)

• rosetta/batch — npm run rosetta:batch [taxonomy|dimensions|seal] (one smart batch per turn; default all)

• dissolve/flat — npm run dissolve:flat (preview with --dry; dissolve flat siblings into index folders)

• mission/gate — npm run mission:gate (check:types + limits:verify + verify:structure + gate/slow-build — fast mission checkpoint)

• gate/unite — npm run enforcement:trinity (enforcement trinity cross-audit after build materialize)

• Save the pair first, then use it — persist before relying on it.

• Agent submission — before any command or CLI edit: save agent/submission + gate/compliance pairs; invoke tasks through node src/pair/enforcement/script/cli/bootstrap/index.ts → sealed src export (script-exits/index.ts for npm scripts); stay under the shell line budget unless allowlisted; validate with build/seal.

• The build fails if this section is removed (commandsSavedInQuantumPairs).

Full zero-token and efficiency math: README §Agents and §Efficiency — no known model is more efficient for deterministic, content-addressed answers from sealed src.