Per-run loop tax (`src/lib/backbone.ts` `LoopTrace`, NVIDIA Vera ingest applied)

Every `/run` + `/run/stream` result's `loop` block carries a timing split (the `done` SSE event mirrors it). Origin: the ingest-codex Vera article — its thesis (an agent loop is a chain of DEPENDENT steps, so orchestrator-side time between model calls sits on the critical path and compounds) applied to Alloy's OWN loop with Alloy's OWN measurements, never NVIDIA's numbers. NOT part of the signed receipt canonical — `receipts.ts` picks explicit fields (attempts + latencyMs), the loop block was never in it, so receipt shape/hash/chain are untouched.

- **`modelMs`** — MEASURED: the sum of EVERY provider-attempt wall window (`latency_ms`, success AND failed attempts — a failed provider call still occupied the loop). These windows include network + provider queueing, so modelMs is never claimed as pure compute.
- **`overheadMs`** — DERIVED (`run wall − modelMs`, floored at 0): Alloy's own orchestration around the model calls — routing/failover bookkeeping, energy-meter samples (up to 2.5 s per dead meter host per run), trace/step bookkeeping, and any self-verification pass (which IS a model call but runs outside the attempt windows — stated in the basis, never hidden). One wall-clock reading feeds BOTH `latencyMs` and the split, so `modelMs + overheadMs === latencyMs` reconciles exactly on the success path. Never claimed as pure CPU time.
- **`peakAttemptMs`** (AirLLM ingest, wave 4) — MEASURED: the single slowest attempt's wall window (max over attempts, 0 when none). The peak-vs-sum reframing: modelMs is the SERIAL sum, the peak is the per-hop ceiling.
- **`serializationTaxMs`** (AirLLM ingest) — DERIVED (`modelMs − peakAttemptMs`, floored at 0): what strict sequential failover cost over the slowest hop alone. A COUNTERFACTUAL, never a realized saving — Alloy does NOT prefetch or parallelize its failover chain, and the basis says so.


- **`deadHopMs`** (AirLLM ingest) — DERIVED: Σ of failed-attempt windows BEFORE the served hop (attempts are recorded in loop order, so everything before the first `ok` row is a dead hop; when nothing served, every hop was dead). Never counts the serving attempt.
- **`timingBasis`** — the basis string verbatim (`LOOP_TIMING_BASIS`), attached to every trace so the split is never separated from what it means.
- **Demo runs** — no model call is made: `modelMs` 0 and all three peak-vs-sum fields 0, the whole wall is honestly orchestrator time. Error path (`AllProvidersFailedError`): the split is still computed over the failed attempts' real windows.
- **UI** — `RunConsole.tsx` Ouroboros-loop block renders `loop tax: <overheadMs>ms orchestrator • <modelMs>ms model windows (MEASURED wall − Σ attempts · split DERIVED)` plus a second line `peak hop: <peakAttemptMs>ms • serialization tax: <serializationTaxMs>ms (counterfactual, never a saving) • dead hops: <deadHopMs>ms (peak-vs-sum · AirLLM ingest)`, full basis on hover. The `alloy/src/lib/backbone.ts` SSE-mirror `LoopTrace` interface is HAND-MAINTAINED and must change in lockstep with the server's.
- **NOT in the signed receipt canonical** — `receipts.ts` picks explicit fields; adding loop fields never changes receipt shape/hash/chain.
- **Verified live 2026-07-12** — laptop-served run: 5714 ms wall = 5158 ms model windows (47 ms failed tower attempt + 5111 ms laptop serve) + 556 ms DERIVED overhead; reconciles exactly. Peak-vs-sum verified same day: modelMs 3610 = 53 ms dead tower hop + 3557 ms laptop peak; serializationTax 53; deadHop 53 — all reconcile.


Self-verification rubric (`src/lib/backbone.ts` verify pass, Lumbra eval-first ingest applied)

The ingest wave-5 Lumbra "eval-first" gap (junction-check was honesty-LABELING only, no graded pass/fail with a declared threshold) closed 2026-07-12: when a run requests `verify: true`, the SAME single bounded self-verify pass now also grades the output against a DECLARED fixed rubric, surfaced as `verification.rubric` on the run result (the `done` SSE event mirrors it; the hand-maintained `alloy/src/lib/backbone.ts` mirror changed in lockstep).

- **DECLARED rubric, fixed** — three criteria (`goal-addressed`, `internally-consistent`, `no-unsupported-claims`), threshold verbatim `PASS iff every criterion is PASS`. The criteria and threshold are code constants, declared in the verify system prompt — never adjusted per run, never learned.
- **One pass, not two** — the rubric rides the EXISTING self-verification model call (a `RUBRIC:` line appended to the critique format); no extra provider call, no loop-iteration inflation (the self-verification doctrine holds: the verify pass never counts as a loop step).
- **Verdicts** — rubric `verdict`: `PASS` / `FAIL` (from parsed per-criterion grades) / `UNPARSEABLE` (the model did not emit a parseable `RUBRIC:` line — shown as exactly that, NEVER coerced to a pass or fail; per-criterion verdicts fall back to `UNGRADED`). The `RUBRIC:` line is stripped from the human-readable critique.
- **Basis (load-bearing)** — verbatim on every rubric: model-REPORTED self-grade by the same model class — never external ground truth; a PASS is never proof of correctness. The rubric attaches ONLY to a real `SELF-CHECKED` verification (never demo output, never when verification was unrequested or failed).
- **UI** — `RunConsole.tsx` renders a rubric block under the verification critique: verdict chip + three per-criterion chips (PASS green / FAIL red / UNGRADED muted) + the verbatim threshold and basis.


- **Verified live 2026-07-12** — laptop `qwen2.5:3b` verified run → `UNPARSEABLE` with all criteria `UNGRADED` (a 3B model ignoring the format is shown as exactly that); `openai` `gpt-5.5` verified run → `PASS` with all three criteria `PASS`, `RUBRIC:` line stripped from the critique — parser proven on a compliant model, honesty proven on a non-compliant one.


Alloy architecture notes (deep detail)

> Relocated verbatim from `replit.md` on 2026-07-12 to keep the README lean. This file is the
> full historical subsystem detail (component wiring, ingest waves 1-9, provider quirks).
> `docs/data-surfaces.md` remains the authoritative per-block upstream reference.


Overview

pnpm workspace monorepo using TypeScript. Each package manages its own dependencies.

**Production**: live at **https://a11oy.net** (custom domain, linked 2026-07-11; DNS on Cloudflare, registrar Namecheap) and https://machine-innovate.replit.app (Replit autoscale deployment).

**Ownership**: This project (Alloy — Agentic Orchestrator) is a product of **SZL Holdings**. Branding reflects "Alloy by SZL Holdings" (hero eyebrow, footer copyright, page title).

**Honesty doctrine (binding)**: every value carries a MEASURED / REPORTED / SIMULATED / UNKNOWN / UNAVAILABLE label; nothing is ever fabricated — failed upstreams show UNAVAILABLE, never invented numbers. Captions state exactly what each upstream's ordering/dates/totals mean. Λ stays Conjecture-1, never "proven".


Stack

- **Monorepo tool**: pnpm workspaces · **Node.js**: 24 · **TypeScript**: 5.9
- **API framework**: Express 5 · **Database**: PostgreSQL + Drizzle ORM
- **Validation**: Zod (`zod/v4`), `drizzle-zod` · **API codegen**: Orval (from OpenAPI spec) · **Build**: esbuild (CJS bundle)


alloy (`artifacts/alloy`, served at `/`)

Single-page React + Vite cockpit for the agentic orchestration backbone (multi-provider: Sovereign GPU (own metal), OpenAI, Moonshot Kimi K2.6, DeepSeek, Qwen, Hugging Face, OpenRouter, Google Gemini). Key components:

- **Run Console** (`RunConsole.tsx`) — streams real model output via SSE (`POST /api/run/stream`); run-key field (localStorage `a11oy_run_key`, sent as `x-a11oy-key` on streams; `main.tsx` wires `setAuthTokenGetter` so generated API calls send it as Bearer) + approval-ticket field (sent `x-a11oy-approval`, never persisted, cleared after the spending run). Renders the per-attempt routing trail, receipt block, ESTIMATED/ZERO/UNKNOWN cost line, the verification rubric chips when `verify:true` (DECLARED 3-criterion rubric graded in the SAME self-verify pass — model-REPORTED self-grade, PASS/FAIL/UNPARSEABLE never coerced, UNGRADED fallback; Lumbra eval-first wave-5 gap CLOSED 2026-07-12; SSE mirror `lib/backbone.ts` in lockstep; detail `docs/data-surfaces.md`), and `RoutingWaterfall.tsx` (latency waterfall from the same trail — bar ∝ MEASURED `latency_ms`, `no timing` when missing, no fabricated segments; served attempt matched by splitting `decision.chosen` on `#`).
- **HoloCanvas** (`HoloCanvas.tsx`) — holographic canvas (starfield/orbit rings/horizon grid, fixed 480px, reduced-motion/visibility aware). DATA-TRUE via `hooks/useHoloData.ts` (reuses existing query keys, no extra fetches): real ISS marker (absent until real data) + provider constellation from `/backbone/status`. Palette #3af4c8.
- **Run Ledger** (`Telemetry.tsx`) — MEASURED: renders key-gated `GET /api/runs/recent` via generated hook; honest empty/UNAVAILABLE/KEY-REQUIRED states.
- **Page layout** (`App.tsx`): two balanced 7/5 grid bands (band 1: RunConsole/FleetTrials/Telemetry/Flywheel/ReceiptChain | HonestyAudit/EstateMesh/ForgePanel/SourceRegistry/MCPPanel; band 2: GridWindow/Orbital/ProviderFleet/Organism | DarpaRadar/VerticalsRadar/ModesAnatomy/LayerFitCodex — `LayerFitCodex.tsx` renders key-less `GET /api/estate/fit` on demand only (presets Qwen 3B/72B + free org/name input, client-side same strict regex as the server); AirLLM wave-4 innovation, detail `docs/data-surfaces.md`), then full-width SovereignEstate, full-width FrontierRadar (internal `md:columns-2` masonry, every block `break-inside-avoid`, per-LeadersGroup breaks), then FormulaCodex | ThesisCorpus side-by-side, then full-width LeanLedger, then full-width OuroborosInvariants, then full-width IngestCodex above the footer. Restructured 2026-07-12 to kill one-sided scroll whitespace — never put the frontier wall back into a narrow grid column.


- **FrontierRadar** + **FormulaCodex** + **ThesisCorpus** — render `GET /api/frontier`: HF model/dataset lists, code/publications/preprint/signal/router frontiers, 50-org leaders board, biomed/curated-papers/research-artifact/practitioner/clinical/security/funding/tooling/policy/capital frontiers, plus 66 self-contained block modules (server `src/routes/frontierBlocks/`, client `components/frontier/`): standards, litigation, attention, demos, grants, crates, books, audio, govuk, extensions, images, journals, worldbank, archive, addons, apps, ukri, forum, maven, lobsters, osf, zenodo, crossref, datacite, westminster, nuget, hansard, packagist, rubygems, flathub, mastodon, dblp, hex, plos, fdroid, cran, pypi, brew, artifacthub, terraform, metacpan, golang, pubdev, jsr, bluesky, softwareheritage, ror, openaire, doaj, dataverse, figshare, dockerhub, snapcraft, usaspending, wikipedia, gleif, openvsx, jetbrains, wordpress, civitai, anaconda, aur, quay, eudata, hfpapers, thesisVersions (SZL's own Zenodo version ledger for the Ouroboros thesis concept, `parent.id`-pinned to record 19944926 — the ONLY query that enumerates it; 36 versions live-verified 2026-07-12; DISTINCT from the `zenodo` title-search block; renders as a collapsible ledger inside `ThesisCorpus.tsx`, not FrontierRadar) (cran+pypi+brew+metacpan share one "Registry-pulse frontier" section; artifacthub+terraform share "Infra-registry frontier"; golang+pubdev+jsr share "Language-registry frontier"; bluesky+wikipedia join the "Attention frontier" section; dockerhub joins "Infra-registry"; snapcraft joins "Desktop"; usaspending joins "Capital"; dataverse+figshare join "Open-science"; openaire+doaj join "Open-access"; softwareheritage gets its own "Source-archive frontier" section; ror gets its own "Research-registry frontier" section; openvsx+jetbrains+wordpress join "Extensions"; anaconda joins "Registry-pulse"; aur joins "Desktop"; quay joins "Infra-registry"; gleif gets its own "Corporate-registry frontier" section, civitai "Creative-model frontier", eudata "EU-data frontier", hfpapers "Community-papers frontier"; npm search q=llm was REJECTED as a new block — it already IS the Tooling frontier; SEC EDGAR full-text search was REJECTED as a new block — it already IS the Capital frontier + verticals edgar) — each with its own REPORTED/UNAVAILABLE state and a caption stating exactly what the upstream's ordering/dates/totals mean (e.g. "top-matching" never "newest" for relevance-ranked registries; index/registration dates never called publication dates; totals only when live-verified real). **Per-block upstream detail, quirks, and render order: `docs/data-surfaces.md` (authoritative — update it with every block change).** Plus the formula ledger and the DOI-pinned thesis corpus (arXiv packages badged **prepared · not posted**).


- **VerticalsRadar**, **OrbitalPanel**, **OrganismPanel**, **EstateMesh** — render `/api/verticals`, `/api/orbital`, `/api/organism`, `/api/backbone/mesh/probe` + `/api/backbone/mesh/history` (per-host uptime strip, "MEASURED · recorded real probes only · gaps are gaps"). Detail: `docs/data-surfaces.md`.
- **SovereignEstate** (`SovereignEstate.tsx`) — renders `GET /api/estate`: full public estate enumeration (ALL szl-holdings GitHub public repos — `type=public` is load-bearing with a token — + ALL SZLHOLDINGS HF assets), DERIVED `alignment` cross-check (name-normalization heuristic, basis surfaced verbatim, never claimed as a verified link), and two fresh-per-request fourth-wall blocks: `self` (build/clock/pid MEASURED) and `observer` (caller's own UA + address echoed, never stored). Detail: `docs/data-surfaces.md`.


api-server (`artifacts/api-server`, served at `/api`)

Express API server hosting the orchestration backbone.

**Endpoints**: `GET /healthz` · `GET /backbone/status` · `GET /sources` · `POST /run` · `POST /run/stream` (SSE: `step`/`done`/`error`) · `GET /runs/recent` · `GET /grid` · `GET /frontier` · `GET /verticals` · `GET /organism` · `GET /orbital` · `GET /estate` · `GET /estate/fit` (Layer-Fit Codex, AirLLM wave-4) · `GET /backbone/mesh/probe` · `GET /backbone/mesh/history` · `GET /receipts/pubkey` · `GET /receipts/recent` · `GET /receipts/checkpoint` · `POST /receipts/verify` · `POST /policy/approvals` (key-gated mint) · `GET /flywheel/status` · `GET /flywheel/export.jsonl` (key-gated) · `GET /honesty` · `GET /forge/models` · `GET /ingest` · `GET /lean` · `GET /invariants` · `GET /policy`. All REPORTED windows documented block-by-block in `docs/data-surfaces.md`.

- **Policy engine** (`src/lib/policy.ts` + `src/routes/policy.ts` + `src/lib/approvals.ts`; omnigent wave-7 gap FULLY CLOSED 2026-07-12): enforced rolling-24h spend cap (`A11OY_SPEND_CAP_USD_DAY`, over the MEASURED ledger tally of per-run ESTIMATED amounts — `runs.cost_usd` persisted only when costStatus=ESTIMATED, `getSpendWindow()`; sum of estimates never billing truth; ledger-down = SUSPENDED fail-open surfaced on `/policy`, unset = honestly OPEN like authMode) + provider allow-list (`A11OY_PROVIDER_ALLOWLIST` csv, filters the ENTIRE failover chain via `RunOptions.allowedProviders`, auto re-picks primary to first allowed configured provider) + **per-action approval gates** (`A11OY_APPROVAL_MODE=required`: every `/run`+`/run/stream` must spend a single-use `apv_` ticket via header `x-a11oy-approval`, minted key-gated at `POST /policy/approvals`; tickets sha256-hashed in-memory only, 10-min TTL, max 200, atomic spend; unset = honestly OPEN, required-without-run-key = MISCONFIGURED fail-closed — mint 503, all runs refused with that reason; enum ENFORCED/OPEN/MISCONFIGURED on `/policy`). `gateRun()` refuses BEFORE any provider call (403 POLICY_PROVIDER_DENIED / 403 POLICY_APPROVAL_REQUIRED / 429 POLICY_SPEND_CAPPED; JSON on `/run`, SSE `error` on `/run/stream`); denied requests are NOT ledger rows (nothing ran — invariants untouched). `PolicyPanel.tsx` (band 1 right column under HonestyAudit; MintApproval UI when ENFORCED, MISCONFIGURED explainer). E2E-verified 2026-07-12 (403 + 429 + CAPPED live; approvals: 403 no-ticket, 401 wrong mint key, mint→spend→reuse-refused, MISCONFIGURED 503). Prod: needs `cost_usd` column in prod DB + republish; policy env optional. Detail: `docs/data-surfaces.md`.


- **Run access key**: `/run`, `/run/stream`, `/runs/recent` gated by `A11OY_RUN_KEY` (Replit **Secret** — global to dev+prod; rotated 2026-07-11; secrets must NEVER go in `.replit`) via `src/lib/runKey.ts` (sha256 + timingSafeEqual, `x-a11oy-key` or Bearer). Gate honestly OPEN when env unset (authMode `ip-ratelimited`; `run-key` when set).
- **MEASURED run ledger**: every run (success AND failure) recorded in Postgres (`runsTable`; `src/lib/runLedger.ts` — lazy guarded `import("@workspace/db")` so missing DATABASE_URL never crashes boot; fire-and-forget). `GET /runs/recent` = last 20 rows, key-gated, honest UNAVAILABLE, 30/min.
- **MEASURED mesh probe history** (`src/routes/mesh.ts`): rows persist ONLY from a real `runProbe()` — cache hits and dedup awaiters never record. `GET /backbone/mesh/history` = last 24h per host, honest empty/UNAVAILABLE, 15/min; rows >7 days pruned.
- **Prod publish checklist**: `A11OY_RUN_KEY` reaches production automatically on republish (deployed build enforces the OLD rotated key until republish); `runs` table must exist in the production DB.
- **`/run` result shape**: honest `loop` (bounded-loop trace + doctrine + **loop tax**: MEASURED `modelMs` = Σ all provider-attempt windows incl. failed attempts, DERIVED `overheadMs` = wall − modelMs (includes meter samples + self-verify pass, never "pure CPU time"), `timingBasis` verbatim; split reconciles exactly with `latencyMs`; demo modelMs=0; from the NVIDIA Vera ingest, applied with OUR measurements never NVIDIA's numbers; NOT in receipt canonical; rendered in RunConsole's Ouroboros block; plus AirLLM wave-4 peak-vs-sum fields `peakAttemptMs` MEASURED max single attempt / `serializationTaxMs` DERIVED modelMs−peak counterfactual / `deadHopMs` DERIVED Σ failed hops before serve — demo all zero; the HAND-MAINTAINED SSE mirror `alloy/src/lib/backbone.ts` LoopTrace must change in lockstep), `cost` (ZERO/ESTIMATED/UNKNOWN — DECLARED price table `lib/pricing.ts` × MEASURED tokens, never invented, NOT in the signed receipt canonical; detail in `docs/data-surfaces.md`), `observer` (endpoint/provider/model/authMode/`servedNode` — the own-metal node that served, or `null` for cloud, never fabricated). The `done` SSE event mirrors this.


- **Backbone code**: `src/lib/backbone.ts` (provider router + agent loop, demo fallback without credentials), `src/lib/registry.ts` (providers + sources), `src/lib/rateLimit.ts` (20/min `/run*`, 30/min `/grid`). Every model call bounded: `maxRetries: 0` + 60s timeout (failover chain IS the retry strategy — MEASURED 2026-07-11: openai v6 default retries hang >70s on a CF 530 node).
- **Per-run MEASURED energy** (`src/lib/energy.ts`): every run result carries an `energy` block — own-metal serving samples the node's szl-meter (tower → meter.a-11-oy.com, laptop → meter2.a-11-oy.com; `SovereignNode.meterHost`, env `A11OY_METER_HOST[_2/_3]`) before/after the serving call; MEASURED = NVML counter delta, WHOLE-GPU (includes concurrent load — never claimed as solely the run's), avgWatts DERIVED; counter reset → UNAVAILABLE; cloud → UNKNOWN; demo → ZERO. NOT in the signed receipt canonical. Verified live 2026-07-12 (laptop 106.9 J / 5.6 s). Detail: `docs/data-surfaces.md`.
- **Providers**: OpenAI via Replit AI integration (`gpt-5.5` — newest the gateway serves; the entire gpt-5.6 family incl. `-sol` is MEASURED unsupported on the gateway 2026-07-12, re-probe before pinning); others on keys: `MOONSHOT_API_KEY`, `DEEPSEEK_API_KEY`, `QWEN_API_KEY`, `HUGGINGFACE_API_KEY` (falls back to `HF_TOKEN`), `OPENROUTER_API_KEY` (**SERVING as of 2026-07-12** — the secret is a PROVISIONING key which cannot serve inference itself (401 "User not found"); `src/lib/openrouterKey.ts` classifies it at boot via `/auth/key` and mints an in-memory runtime key ($10 limit, stale `a11oy-runtime-*` keys pruned, throttled re-mint on failure); verified live: `openrouter/auto` → real completion. Free-tier account: `:free` models can 429 upstream; auto-routing works. Prod picks this up on next republish.), `GEMINI_API_KEY` (pinned `gemini-3.5-flash`). Optional `<PROVIDER>_MODEL` / `<PROVIDER>_BASE_URL` overrides; `ALLOW_REMOTE_MCP=1`.


- **Sovereign GPU provider** (own metal, **default**, multi-node): node 1 tower `gpu.a-11-oy.com/v1` `llama3-szl-finetuned-q4:latest` (LIVE, keyless) via `A11OY_MODEL_BASE_URL`; node 2 laptop `gpu2.a-11-oy.com/v1` `qwen2.5:3b` (SERVING as of 2026-07-12 — fresh CF-Access service token in secrets; anon still GATED by design; verified `servedNode: laptop`) via `A11OY_MODEL_BASE_URL_2`; node 3 `szl-nemo` on the tower (env staged; serves once the owner pulls it — recipe in szl-forge, HF card `SZLHOLDINGS/szl-nemo`). Per-node config in `registry.ts` `sovereignNodes()` (`SOVEREIGN_MODEL[_2/_3]` never cross-defaulted, `A11OY_GPU_TOKEN[_2/_3]`, CF Access creds, `SOVEREIGN_NODE_LABEL[_2/_3]` = `tower`/`laptop`/`tower·nemo`). `providerToTargets()` expands sovereign into one target per node — failover tower → laptop → tower·nemo before any cloud fallback (verified live 2026-07-11). `configured:false` nodes show `(offline)`, never faked. Owner autostart: `docs/tower-autostart.ps1`.
- **Notarized run receipts** (`src/lib/receipts.ts`, `src/routes/receipts.ts`): every run result carries an ed25519-signed receipt over sha256 hashes (plaintext never in the receipt) + routing trail + servedNode; hash-chained in Postgres. Key via HKDF from `SESSION_SECRET` (honestly `UNSIGNED` when unset). `POST /receipts/verify` verifies the EXACT canonical bytes. `GET /receipts/recent` = public chain window, sha256 chain RECOMPUTED per request, chainStatus VERIFIED/PARTIAL/BROKEN/EMPTY. `GET /receipts/checkpoint` = signed transparency-log checkpoint, recomputed + re-signed per request. `ReceiptChain.tsx` renders it with **in-browser WebCrypto Ed25519 verification** (verdict computed client-side, honest failure states, never a fake pass). Detail: `docs/data-surfaces.md`.
- **Sovereign flywheel** (`src/routes/flywheel.ts`): MEASURED count of training samples from own-metal-served, non-demo, successful runs only; honest zero. `FlywheelPanel.tsx`.


- **Live honesty audit** (`src/routes/honesty.ts`): `GET /honesty` — cache-only self-report from the 8 REPORTED windows; NEVER triggers upstream fetches. `HonestyAudit.tsx` (right column, top).
- **Forge probe** (`src/routes/forge.ts`): `GET /forge/models` — MEASURED per-sovereign-node model presence (probes each configured node's `/models`); `ForgePanel.tsx` flips SZL-1 pipeline steps on this evidence only (create=DONE only when `szl1` is actually listed; train stays owner-REPORTED).
- **Ingest codex** (`src/routes/ingest.ts` + `src/data/ingestRegistry.ts`): `GET /ingest` — DECLARED study registry (wave 1 2026-07-12: ktransformers, zml, profiles glesmyno/yunawyner; wave 2 2026-07-12: org Lean/proof estate lutar-lean, lean-kernel, szl-formula-ledger, szl-lake — first-party, notes still DECLARED, szl-lake entry resolves the Lean-`lake` name collision; wave 3 2026-07-12: first `article` kind — NVIDIA Vera blog, © NVIDIA principles-studied, all perf numbers stay NVIDIA/partner-REPORTED, applied as the run loop-tax metric; license+attribution verbatim, never re-badged; wave 4 2026-07-12: lyogavin/airllm Apache-2.0 — layer-streaming thesis applied TWICE: the `/estate/fit` Layer-Fit Codex and the loop peak-vs-sum fields; all AirLLM VRAM figures stay README-REPORTED, never restated as SZL results; wave 5 2026-07-12: two `article` kinds — palantir-security-forge (© Palantir) + lumbra (© Lumbra), commercial defense-AI sites principles-studied, NO assets/fonts/copy re-used, ALL their capability/customer/deployment/market claims stay Palantir/Lumbra/press-REPORTED never SZL fact; model-agnostic pipelines + receipt-provenance recorded as CONVERGENCE not adoption (already load-bearing in Alloy pre-study); Lumbra entry adds the `frontend` "fashion thinking" takeaway = visual language studied as INSPIRATION only, Alloy keeps its #3af4c8 identity, no Lumbra amber #F5C94A/fonts/logo — lean into Alloy's EXISTING truth-surfaces, never repaint; wave anchors the REAL checkable field leaders with evidence: arXiv CVE-Bench 2503.17332 / SEC-bench 2506.11791 NeurIPS'25 / PatchEval 2511.11019 / ExploitBench 2605.14153 + repos usestrix/strix, vxcontrol/pentagi, SEC-bench/SEC-bench; wave 6 2026-07-12: `article` seed-iq (© AIX Global Innovations, Inc. — Seed IQ™ quantum concept) — THREE labels never blended: (a) cited physics PRIMITIVES are REAL peer-reviewed lit, DOI-verified (no-cloning Wootters&Zurek 1982, teleportation Bennett 1993, GKLS/Lindblad 1976, dissipative-stabilization Mirrahimi 2014 + Shor/Steane/Gottesman/Knill QEC); (b) the Seed IQ™ SYNTHESIS + AIX's broader claims (adaptive multiagent control, Active Inference, patented ΑΩ FoB HMC engine, quantum/data-center deploys, zenodo.org/records/20585365) are AIX-DECLARED, unaudited by SZL, NEVER restated as SZL fact; (c) **Alloy is CLASSICAL with NO quantum hardware, claims none** — every mapping is explicit ANALOGY/inspiration only ((output,receipt)↔(ρᴸ,Mₜ); recompute-per-request receipts↔restore-not-copy; UNAVAILABLE/self-verify damping↔dissipation-as-restoring-force; chainStatus↔Mₜ admissibility), changes NO mechanism; `frontend` fashion-thinking takeaway takes the governed-value/restore/commit/admissibility VOCABULARY as inspiration, no AIX asset/logo/colour/trademark re-used, Alloy keeps #3af4c8); wave 7 2026-07-12: `repo` omnigent-ai/omnigent (Apache-2.0, alpha) — open-source meta-harness over Claude Code/Codex/Cursor/OpenCode/Hermes/Pi + custom YAML agents w/ policy governance, OS (bwrap/seatbelt+L7 egress) & cloud (Modal/Daytona/E2B/CoreWeave/K8s/Databricks) sandboxing, session portability, live collab; studied honestly (SZL never ran it, audited no code, re-uses no code/logo/asset, only live GitHub meta REPORTED); convergences = CONVERGENCE not adoption (Alloy's multi-provider router+failover already generalize the meta-harness; ed25519 receipt chain already embodies governed accountability); the one new idea — a first-class policy engine — was recorded as a DECLARED gap, then FULLY CLOSED 2026-07-12: spend cap + provider allow-list + per-action approval gates all BUILT for real (see Policy engine above); OS-sandboxing noted LIMITED-applicability (Alloy orchestrates bounded model calls, not arbitrary shell)); wave 8 2026-07-12: `repo` NYUMedML/Neuro-JEPA (arXiv 2606.14957, built on V-JEPA 2) — 3D ViT+MoE (2 shared+16 experts/6 active) brain-scan foundation model, JEPA latent-predictive objective (predict latents of masked regions, never voxel reconstruction) over 1,551,862 scans; **split license recorded verbatim, never blended**: code MIT © 2026 The NeuroJEPA Authors, weights CC-BY-NC-ND-4.0 (gated, HF 401), GitHub SPDX NOASSERTION, paper CC BY 4.0; ALL perf/accuracy/dataset numbers stay paper-REPORTED (SZL ran nothing, downloaded no gated weights, reproduced no benchmark, re-uses no code/weights/figure/asset, only live GitHub meta REPORTED); the JEPA move (verify in a compact DERIVED latent space, not the raw object) is OPERATIONALIZED as the `latentVerification` MEASURED coverage block on `/invariants` — honest ANALOGY only, Alloy's "latent space" is a crypto digest+signature NOT a learned embedding, nothing trained/predictive, changes no mechanism, does not upgrade Λ); wave 9 2026-07-12: `article` compute-pillars — OWNER-SUPPLIED UNATTRIBUTED PASTE (CPU/GPU/LPU/NPU "4 pillars" cheat sheet; no author/byline/publication/date/URL → authorship+license UNKNOWN verbatim, `url:""` renders an honest non-link in IngestCodex, never a fabricated href); checkable kernel (the 4 silicon classes are real product categories — "LPU" = Groq's marketing name, NPUs = SoC units) separated from editorial framing (analogies, evolution arrow, "officially dead"/"burning your budget", un-benchmarked LPU speed claims — all author-REPORTED, never SZL fact); APPLIED as the **fleet substrate ledger**: every provider on `/backbone/status` carries required `substrate`/`substrateLabel`/`substrateBasis` (sovereign = "GPU" DERIVED from szl-meter NVML evidence, class only never die/SKU; EVERY cloud = UNKNOWN, silicon unobservable through the API, never guessed — Google's TPU marketing stays Google-REPORTED; OpenRouter doubly unobservable; hand-maintained mirror `alloy/src/lib/backbone.ts` `BackboneProvider` updated in lockstep); `ProviderFleet.tsx` renders the Substrate row + wave-9 caption, offline mock roster claims no substrate; LPU/NPU honestly ABSENT, never claimed; "ecosystem of specialists" = CONVERGENCE with the pre-existing router, not adoption); wave 10 (agent-memory: Perplexity Brain + Zep/Graphiti + Mem0 + Letta) + wave 11 (hallucination/decay: Ferguson + Topaz + semantic-uncertainty + SelfCheckGPT + Vectara-tooling-survey + Rekor-provenance-frontiers) full detail in replit.md + docs/data-surfaces.md; wave 12 2026-07-12: code-forge / git-hosting frontier — 8 sources: `repo` radicle-dev/heartwood (Apache-2.0; P2P sovereign git, Ed25519-signed gossip-replicated refs — the crown-jewel ANALOGY to Alloy's receipt chain, `receipt-ed25519-verify` + `receipt-chain-continuity`; archived radicle-upstream recorded as dead), `repo` go-gitea/gitea (MIT; single-Go-binary self-hostable sovereignty + GitHub-Actions-compatible portable CI), `repo` gitlabhq/gitlabhq (license verbatim MIT-CE / proprietary-EE — GitHub SPDX NOASSERTION because the mirror carries BOTH in one tree, never simplified to MIT; MR-approval-rules → Alloy's per-action approval tickets, integrated SAST/DAST/SBOM → the SLSA-L1-honestly-below-L2 target), `repo` gogs/gogs (MIT; radical minimalism = honest fit for constrained own metal), `repo` theonedev/onedev (MIT; built-in CI/CD + symbol-level code search → the shape of a self-contained sovereign workspace, DECLARED roadmap only), `article` codeberg.org/forgejo/forgejo (GPL-3.0-or-later, github 404 → NOT_APPLICABLE; copyleft-anti-capture governance = ANALOGY to the no-repaint doctrine, explicitly NOT adopted, license = owner-only), `article` sr.ht/SourceHut (per-component AGPL/GPL, no GitHub; minimal-JS don't-trust-the-UI → Alloy's in-browser Ed25519 verifier + `receipt-columns-consistent`), `article` github.com supply-chain (proprietary platform, studied pieces carry own upstream licenses; Sigstore-backed Artifact-Attestations + SLSA provenance = the exact next rung for the SZL-1 model pipeline [DECLARED gap, cosign-attest after rebirth.ps1], protected-branches/required-reviews = machine form of the two-account PR flow). Binding wave-12 doctrine: SZL runs NO git host (code on github.com/szl-holdings + Carlota-1/Machine-Innovate); every forge primitive is a labeled ANALOGY to an EXISTING Ouroboros invariant, adopting a forge is a DECLARED roadmap gap, non-GitHub forges are honestly kind `article` (github-meta NOT_APPLICABLE, never a faked lookup), zero proofs added, Λ stays Conjecture-1, corpus stays 269; evidence packet `.local/ingest-lab/wave12/`; wave 13 2026-07-14: frontier-retrieval study — `article` rrf-cormack2009 (© ACM 2009, SIGIR, DOI 10.1145/1571941.1572114; the ONE adoption: `/brain/ask` display order = RRF fusion k=60 of BM25 + distinct-term coverage, equation re-implemented, floor still gates on raw BM25, fixture-pinned exactness never quality) + `repo` microsoft/graphrag MIT (retrieval-through-relations; generated community summaries in the index = DECLARED gap, ANALOGY to the lexical Brain Atlas), naver/splade CC BY-NC-SA 4.0 © NAVER (NON-COMMERCIAL — study only, no code; names the vocabulary-mismatch ceiling), parthsarthi03/raptor MIT (citable generated summaries = worst-case taint under the citation gate, not adopted), stanford-futuredata/ColBERT MIT (late interaction = ANALOGY; neural encoder is the dependency wall the lane stays behind), xhluca/bm25s MIT (eager sparse scoring = named optimization path, adopt-when-measured); corpus stays 269, nothing upgrades Λ; detail `docs/data-surfaces.md`; wave 14 2026-07-14: open-weights-frontier — six `article` HF model-card studies: zai-org/GLM-5.2 MIT, moonshotai/Kimi-K2.6 Modified-MIT (lane-truth: the moonshot pin `kimi-k2.6` verified to EXIST with that identity/license — never a served/capability claim, lane honestly offline until keyed), deepseek-ai/DeepSeek-V4-Pro + -Flash as ONE family entry MIT (alias lesson: `deepseek-chat` pin ⇒ served model UNKNOWN until the provider response names it — receipts report the SERVED id verbatim, UI never captions the lane "V4"), MiniMaxAI/MiniMax-M3 license recorded VERBATIM as HF license:other + license_name minimax-community (no "effectively-Apache" paraphrase — license text not license vibe gates use), mistralai/Mistral-Large-3-675B-Instruct-2512 Apache-2.0, Qwen/Qwen3-235B-A22B Apache-2.0; all licenses HF-card-verified 2026-07-14, ZERO adoptions, every benchmark/price/positioning number stays the vendor's/reviewers' REPORTED claim, corpus stays 269) + REPORTED live GitHub meta (per-source UNAVAILABLE; articles get NOT_APPLICABLE — healthy, never fetched, ≠ UNAVAILABLE; 10-min cache, 30/min). `IngestCodex.tsx` (full-width above footer). Detail: `docs/data-surfaces.md`.


- **Lean proof ledger** (`src/routes/lean.ts` + `src/data/leanKernelCheck.ts`): `GET /lean` — REPORTED CI verdicts (lutar-lean's own lake-build/lean workflow runs, failures shown as-is) + REPORTED corpus counts (repo's committed `lean_numbers.json` verbatim: 1323/22/254 @sampler-putnam-10) + DECLARED locked-proven = 8 {F1,F4,F7,F11,F12,F18,F19,F22} (re-locked 2026-06-10; machine-enforced by no-axiom `locked_count_eight`) + MEASURED local kernel check (`.local/lean-lab/run-lean-lab.sh` targeted `lake build` of the Λ modules in this container; verdict transcribed VERBATIM into `leanKernelCheck.ts`, dev prefers fresher `.local/lean-lab/kernel-check.json` — fs read gated OFF in production, prod serves the committed constant only; FAIL rendered as FAIL, never retried-at-older-sha until green; first run 2026-07-12: **PASS** @85dee499 v4.18.0, 15s build after mathlib cache; lab must run as a temporary workflow — detached nohup processes get reaped) + doctrine-locked Conjectures 1+2 (no PASS upgrades them). 10-min/30s-negative cache, 15/min. `LeanLedger.tsx` (full-width between FormulaCodex|ThesisCorpus and IngestCodex). Detail: `docs/data-surfaces.md`.
- **Ouroboros invariants** (`src/routes/invariants.ts` + `src/lib/runLedger.ts` `getInvariantRunRows`/`getFlywheelLineage`): `GET /invariants` — MEASURED runtime self-consistency invariants recomputed per request over the enumerated ledger window (`INVARIANT_LIMIT=10000`, count = enumerated rows only). 8 FALSIFIABLE checks (receipt-chain-continuity REUSING `getReceiptChain` verbatim, ledger-failure-shape, served-run-has-model, signed-columns-atomic, loop-steps-positive LOWER-bound-only, receipt-ed25519-verify, receipt-columns-consistent, flywheel-lineage — the flywheel eats only its own verified own-metal tail). Public but hashes/row-ids ONLY (plaintext never selected — that stays key-gated on `/runs/recent`); 15/min; honest top-level UNAVAILABLE. Statuses HOLDS/VIOLATED/KEY_ROTATED/NO_DATA/UNAVAILABLE. **Doctrine (binding)**: only genuinely falsifiable predicates — checks TRUE BY CONSTRUCTION are theater and EXCLUDED (loop-tax reconciliation identities are NOT surfaced; the loop upper bound `targets.length` is not persisted so only `loopSteps≥1` is asserted); these are runtime checks DISTINCT from the Lean corpus, NEVER paired with LOCKED_PROVEN {F1,F4,F7,F11,F12,F18,F19,F22}, and NONE upgrade Λ (stays Conjecture-1). Payload ALSO carries `latentVerification` (ingest wave 8 / Neuro-JEPA operational wiring): a MEASURED coverage ratio (NOT an invariant) = fraction of the enumerated window verified purely in hash/signature space (ed25519-over-sha256 tally computed ONCE in invariant #6 and reused; `verified/enumerated`, with honest `rotated`/`unsigned` complements + `tamperFailed` that lowers the ratio); explicit ANALOGY to the JEPA latent-space objective, but Alloy's "latent space" is a crypto digest+signature NOT a learned embedding — nothing trained/predictive, deliberately a coverage metric not a HOLDS/VIOLATED predicate, does not upgrade Λ; UNAVAILABLE when signing key unset or DB unreachable. `OuroborosInvariants.tsx` (full-width between LeanLedger and IngestCodex; ∞ icon, #3af4c8) renders the coverage strip above the invariants list. Live 2026-07-12: 22 runs/7 samples, 7 HOLD, 0 VIOLATED, failure-shape NO_DATA; latentVerification 20/22 verified (91%), 2 unsigned. Detail: `docs/data-surfaces.md`.


- **Sentry (env-gated, inert)**: api-server inits `@sentry/node` only when `SENTRY_DSN` set; alloy lazy-imports `@sentry/react` only when `VITE_SENTRY_DSN` set at build. `@sentry/*` must stay in the esbuild `external` list in `artifacts/api-server/build.mjs`. No DSN yet — Sentry org blocks member project creation (owner action).


mockup-sandbox (`artifacts/mockup-sandbox`, served at `/__mockup`)

Design canvas sandbox.


Key Commands

- `pnpm run typecheck` — full typecheck across all packages
- `pnpm run build` — typecheck + build all packages
- `pnpm --filter @workspace/api-spec run codegen` — regenerate API hooks and Zod schemas from OpenAPI spec
- `pnpm --filter @workspace/db run push` — push DB schema changes (dev only)

See the `pnpm-workspace` skill for workspace structure, TypeScript setup, and package details.


References

- `docs/data-surfaces.md` — **authoritative** block-by-block upstream reference for every REPORTED data window (frontier, verticals, grid, orbital, organism, mesh, estate) plus receipts/flywheel/honesty and cost accounting — caches, rate limits, honesty rules.
- `docs/OWNER-SETUP.md` — owner-side setup (GPU nodes, CF Access).


Sovereign fleet + Forge — honesty-doctrine audit

**Scope (T004).** A read-through of every sovereign-node, hosted-provider, and
SZL-Forge/SZL-1 surface in this repo to confirm each one carries an honest label
(MEASURED / REPORTED / DECLARED / DERIVED / UNKNOWN / UNAVAILABLE) and never
fabricates a number, an "online", or a benchmark. For every slot this doc states
the **honest label today** and the **one owner action that would flip it to
MEASURED**.

**Ground truth read (not re-measured here):**
`artifacts/api-server/src/lib/registry.ts` (`providers`, `sovereignNodes()`),
`artifacts/api-server/src/routes/forge.ts`, `.../routes/sovereign.ts`,
`.../routes/mesh.ts`, `docs/data-surfaces.md`, `docs/OWNER-SETUP.md`, and the
`docs/forge/` kit (`README.md`, `szl_forge.py`, `szl_dataset.jsonl`, `Modelfile`).

**Doctrine anchors honored throughout:** offline nodes show
`(offline)` / `UNAVAILABLE`, never a faked reading; `szl-nemo` stays
"prepared · not serving" until a live probe; **no MEASURED benchmark exists for
any fine-tune — quality is UNKNOWN until measured**; Λ stays Conjecture‑1; the
8 locked-proven families and the 749/14/163 Lean numbers are untouched by this
pass; `#3af4c8` unchanged.


> **How to read the labels.** *MEASURED* = the serving process observed it on a
> live probe this request-cycle. *REPORTED* = a value the owner or an upstream
> stated that Alloy passes through but cannot itself verify. *DECLARED* = a
> static owner-stated fact (env / repo). *DERIVED* = computed from measured
> evidence. *UNKNOWN* = honestly unobservable. *UNAVAILABLE* = a fetch that was
> attempted and failed — shown as silence, never a placeholder.

---


1. The three sovereign own-metal nodes

Nodes are produced by `sovereignNodes()` in `registry.ts`. A node exists in the
failover list **only when its base-URL env is set** — an unset node is silently
absent, never a fabricated endpoint. Node models are never defaulted to each
other (the laptop may serve a smaller model than the tower; claiming otherwise
would be a fabrication).

| Slot | env base-URL | Default label | Live status *(REPORTED in `OWNER-SETUP.md`, 2026‑07‑12 — not re-measured here)* | How the code labels it | Owner action → MEASURED |
|------|--------------|---------------|--------------------------------------------------------------------------------|------------------------|--------------------------|
| **Node 1 — tower (OMEN, RTX 4060 Ti)** | `A11OY_MODEL_BASE_URL` | `tower` | `gpu.a-11-oy.com` **TUNNEL DOWN (530)** — cloudflared connector not up | `/backbone/sovereign/probe` → `UNREACHABLE` + `MEASURED` latency/error, or `OFFLINE` + `UNAVAILABLE` when the env is unset; `/forge/models` row → `UNAVAILABLE` with the real reason | Run `tower-autostart.ps1` (OWNER-SETUP §1) so cloudflared + `ollama serve` come up as services; when `gpu.a-11-oy.com/v1/models` returns 2xx the probe rows flip to `LIVE` / `OK` (MEASURED). |
| **Node 2 — laptop (RTX 5050)** | `A11OY_MODEL_BASE_URL_2` | `laptop` | `gpu2.a-11-oy.com` **SERVING** behind Cloudflare Access; anonymous callers honestly `GATED (403)`; a real `/api/run` was served with `servedNode: laptop` | mesh probe → `GATED` for the public door (tunnel+service up, caller unauthorized); `/forge/models` → `OK` with the model list when Alloy's CF‑Access service token is presented | Already MEASURED-serving via the service token in `A11OY_GPU_CF_ACCESS_ID`/`_SECRET`. No action; rotate the token per OWNER-SETUP §2 if it expires. |
| **Node 3 — tower·nemo / szl-nemo** | `A11OY_MODEL_BASE_URL_3` | `tower·nemo` | Not wired → **absent** from the failover list; `szl-nemo` is **"prepared · not serving"** | Absent unless its base-URL env is set; when set, `/forge/models` reports `szlNemoPresent` **only** from a live `/v1/models` list (MEASURED); never assumed | Point `A11OY_MODEL_BASE_URL_3` (+ `SOVEREIGN_MODEL_3=szl-nemo`) at the Ollama instance actually serving `szl-nemo`; presence flips to MEASURED on the next probe that lists it. |


1. The three sovereign own-metal nodes

**Energy meters (context for the substrate label).** Per OWNER-SETUP.md
(2026‑07‑12): `meter2.a-11-oy.com` (laptop) is **LIVE** — MEASURED NVML watts +
joules on the RTX 5050; `meter.a-11-oy.com` (tower) is **TUNNEL DOWN**. Node VRAM
is **never MEASURED** — the szl-meter exporters expose no NVML memory gauge
(live-verified 2026‑07‑12), so `A11OY_NODE_VRAM_GB[_2/_3]` is a **DECLARED**
owner value or `null`, and is never guessed from GPU marketing specs.

**Verdict — nodes:** honest. Offline/absent nodes surface as
`OFFLINE`/`UNREACHABLE`/`UNAVAILABLE` with a real reason and never a fabricated
model list. `szl-nemo` correctly stays "prepared · not serving" until a live
probe lists it. No change required.

---


2. The sovereign compute-substrate class

`registry.ts` assigns the sovereign provider `substrate: "GPU"` with label
**DERIVED** and an explicit basis: it is derived from MEASURED evidence (the
szl-meter exporters sample NVML energy counters, and NVML exists only on NVIDIA
GPUs) — a **class** claim, never a die/SKU claim. Every cloud provider is
`substrate: "UNKNOWN"` / label `UNKNOWN` — serving silicon is unobservable
through an OpenAI-compatible API and is never guessed; Google's TPU story stays
vendor-REPORTED, never restated as SZL fact. No LPU or NPU serves in this fleet
and none is claimed.

**Verdict — substrate:** honest and correctly scoped (class, not SKU). No change
required. *Nuance worth the owner's awareness:* the DERIVED-GPU basis rests on
NVML meter samples; with the tower meter currently TUNNEL DOWN, the live NVML
evidence is coming from the **laptop** meter. The claim remains true as a class
statement, but the "tower/laptop" phrasing in the basis is broader than what is
live-metered right now — kept as written because it describes the evidence class,
not a real-time reading.

---


3. Hosted providers (free/paid API fleet)

Eight provider slots in `registry.ts`. The **only** availability signal Alloy can
honestly assert per provider is `configured` — whether the required key/base-URL
env is present. Pricing tier (free vs paid) is a **vendor-DECLARED** attribute
Alloy does not verify and does not restate as fact.

| Provider | `configured` gate | Substrate | Model default (with note) |
|----------|-------------------|-----------|----------------------------|
| Sovereign GPU | any `A11OY_MODEL_BASE_URL[_2/_3]` set | **GPU · DERIVED** | `SOVEREIGN_MODEL` \|\| `sovereign-llm`; base-URL falls back to `gateway.a-11-oy.com (offline)` when unwired |
| OpenAI | `AI_INTEGRATIONS_OPENAI_BASE_URL` + `_API_KEY` | UNKNOWN | `gpt-5.5` — pin carries a MEASURED note (5.6 family 400'd on 2026‑07‑12; re-probe before pinning) |
| Moonshot Kimi | `MOONSHOT_API_KEY` | UNKNOWN | `kimi-k2.6` |
| DeepSeek | `DEEPSEEK_API_KEY` | UNKNOWN | `deepseek-chat` |
| Qwen | `QWEN_API_KEY` | UNKNOWN | `qwen-plus` |
| Hugging Face | `HUGGINGFACE_API_KEY` \|\| `HF_TOKEN` | UNKNOWN | `openai/gpt-oss-120b`; router fans out across third-party providers |
| OpenRouter | `OPENROUTER_API_KEY` | UNKNOWN | `openrouter/auto`; vendor **and** silicon vary per request |
| Google Gemini | `GEMINI_API_KEY` | UNKNOWN | `gemini-3.5-flash` — MEASURED live 2026‑07‑11 |


**UI cross-check (`ProviderFleet.tsx`).** Availability is only asserted when real
backend data has been fetched (`knowAvailability`): a provider is `Ready` only
when `configured` is true from live/last-known status; otherwise `Demo`; and when
the backend has never been reached the badge is honestly `Unknown` with
"status unknown · backend unreachable" — the offline static roster is **never**
presented as "Ready". The sovereign first-light button shows real
`LIVE`/`UNREACHABLE`/`OFFLINE` with a MEASURED timestamp. The substrate footnote
restates the DERIVED-GPU-vs-UNKNOWN-cloud rule verbatim.

**Verdict — providers:** honest. `configured` is the correct, non-overclaiming
availability signal; cloud substrate is uniformly UNKNOWN; the UI degrades to
`Unknown` rather than faking readiness. No change required.

---


4. Forge / SZL-1 pipeline

`routes/forge.ts` is a genuine MEASURED probe: it asks each configured node's own
`/v1/models` what it actually serves (same base-URL + auth the router uses),
carries `label: "MEASURED"`, a real `checkedAt`, a ≤60s cache whose `checkedAt`
always reflects the real probe time, and returns `UNAVAILABLE` + the real
HTTP/error reason on failure. Presence matching is exact-or-tag-prefixed
(`szl1` matches `szl1:latest`, never `szl10`). A model being **present** is
reported separately from being the **configured serving** model — the two are
never conflated.

`ForgePanel.tsx` derives four steps, each with the correct honesty grade:

| Step | State source | Honest grade |
|------|--------------|--------------|
| **Kit published** | hard `DONE` | **DECLARED** — the repo `github.com/szl-holdings/szl-forge` is public and linked |
| **Train on RTX 5050** | hard `RUNNING` | **owner-REPORTED, not observable by Alloy** — Unsloth QLoRA · Qwen2.5-3B 4-bit; Alloy cannot see the owner's local machine |
| **`ollama create szl1`** | flips on probe | **MEASURED** — `DONE` only when a node's live `/v1/models` lists `szl1`, else `PENDING`, with the real basis string |
| **Serve `SOVEREIGN_MODEL=szl1`** | flips on probe | **MEASURED** — `DONE` only when a node is configured **and** lists `szl1`; `READY` when present but not yet the serving model (env flip pending); else `PENDING` |


4. Forge / SZL-1 pipeline

The `docs/forge/` kit is consistent with this: its README states outright that
"quality is UNKNOWN until measured. No benchmark or speedup is claimed. This is
not a hand-tuned CUDA/Triton binary," and that a node "stays honestly labeled
'prepared · not serving'" until a live probe succeeds. The panel footer keeps the
scope honest: "Fine-tune kit for SZL-1 — not from-scratch pretraining."

**Fine-tune quality:** **UNKNOWN.** No MEASURED benchmark exists for SZL-1 or
`szl-nemo` anywhere in the repo, and none is asserted. Flipping this to MEASURED
requires the owner to run a real evaluation and record the method + numbers; only
then may any quality claim be made.

**One label/copy fix applied (in-shape, no schema change).** The "Train on RTX
5050" step previously read `owner-reported`. Because Alloy genuinely cannot
observe the owner's local training run, the detail now reads
`owner-reported, not observable by Alloy` so the perpetual `RUNNING` badge cannot
be misread as a live/measured signal. Purely client-side copy in
`ForgePanel.tsx`; the local `PipelineState` enum, response schema, endpoints, and
OpenAPI spec are untouched (codegen remains T001's lane).


4. Forge / SZL-1 pipeline

**Verdict — Forge:** honest. `create`/`serve` flip on MEASURED evidence only;
`kit` is DECLARED; `train` is owner-REPORTED and now explicitly marked
unobservable; quality stays UNKNOWN.

---


5. Owner action checklist — what flips each slot to MEASURED

1. **Tower online** — run `tower-autostart.ps1` (secure the keyless Ollama port
   first, OWNER-SETUP §1). When `gpu.a-11-oy.com/v1/models` returns 2xx, the
   sovereign probe → `LIVE` and the Forge tower row → `OK` (both MEASURED).
2. **Tower meter** — start the meter service so `meter.a-11-oy.com` serves NVML
   watts/joules for the tower (laptop meter already LIVE).
3. **szl-nemo (node 3)** — set `A11OY_MODEL_BASE_URL_3` + `SOVEREIGN_MODEL_3=szl-nemo`
   at the Ollama serving it; presence flips to MEASURED on the next probe that
   lists it. Until then it correctly reads "prepared · not serving".
4. **SZL-1 create/serve** — `ollama create szl1` on a wired node, then set
   `SOVEREIGN_MODEL=szl1`; the Forge steps flip to MEASURED-`DONE` automatically.
5. **Fine-tune quality** — run a real eval and record method + numbers; only then
   may quality move off UNKNOWN. No benchmark or speedup may be claimed before
   that measurement exists.


6. Summary

The sovereign, provider, and Forge surfaces are already honesty-doctrine
compliant: offline/absent nodes and meters read `OFFLINE`/`UNREACHABLE`/`TUNNEL
DOWN`/`UNAVAILABLE` with real reasons; `configured` is the only availability
claim for cloud providers; substrate is DERIVED-GPU (class) for own metal and
UNKNOWN for every cloud; Forge `create`/`serve` flip only on MEASURED `/v1/models`
evidence; and fine-tune quality is left UNKNOWN with no fabricated benchmark. The
single change made in this pass is a one-line copy clarification on the Forge
`train` step to mark it explicitly unobservable by Alloy. No schemas, endpoints,
`openapi.yaml`, or codegen were touched.


Alloy Release Checklist (repeatable)

The honesty doctrine is a release gate, not a nicety. A build that fabricates,
repaints, or over-claims does not ship — even if every automated check is green.


1. Automated pre-flight (dev)

Run all three; each must report clean before proceeding.

- **Typecheck** — `pnpm run typecheck` → every package prints `Done`.
- **Security** — `pnpm --filter @workspace/scripts run security-check` → `ALL CHECKS PASSED`
  (CORS allow-list holds, security headers present, no secret/DB leakage in `/healthz`).
- **Reliability** — `pnpm --filter @workspace/scripts run reliability-check` → `ALL CHECKS PASSED`
  (`/healthz` shape, no sensitive data, `Cache-Control: no-store` on dynamic endpoints, rate-limit headers on gated endpoints).


2. Wall data smoke (dev)

Curl every wall endpoint through the shared proxy (`http://localhost:80/api/...`); each must
return HTTP 200 **and** carry its correct honesty label (a wall with no live data must render
`UNAVAILABLE`, never an invented number):

```
healthz  backbone/status  frontier  velocity  leaders  quant  paper  decay
ingest   lean  invariants  honesty  memory  formulas/answers
```


3. Run-key gate (dev)

- Keyless `POST /api/run` must return **401** whenever `A11OY_RUN_KEY` is set (fail-closed,
  refused before any provider call). If the key is unset the gate is honestly OPEN.
- With the key (`x-a11oy-key` header) a run streams a routing trail + a receipt.


4. Render check (dev)

Screenshot `/` and confirm:

- Brand accent is teal `#3af4c8` (LIVE pill, primary highlights). Amber only on semantic
  status labels — see doctrine gates below.
- Hero + every wall render; no blank/crashed sections; no raw stack traces.
- Provenance labels (MEASURED / REPORTED / DECLARED / SIMULATED / DERIVED / UNKNOWN / UNAVAILABLE)
  are present on the page.


5. End-to-end (when the test harness is available)

Run an e2e smoke across hero → Run Console → every wall. The Playwright harness is
occasionally unavailable (`Notebook not found`); when it is, fall back to steps 2–4, which
cover the same surface via backend + render verification.


Doctrine gates (binding — never ship if violated)

- **No fabrication.** Every value carries a provenance label. Failed upstreams show
  `UNAVAILABLE`; nothing is invented to fill a gap.
- **Palette.** Brand accent stays `#3af4c8` — never repaint to another identity. Amber is a
  **semantic status color** (UNAVAILABLE / UNMEASURABLE / TIMEOUT / PARTIAL / pending) — never
  mass-convert amber → teal; only the decorative glow utilities in `index.css` are brand-teal.
- **Claims.** Λ stays Conjecture-1 (never "proven"); locked-proven count = 8; corpus = 269.
- **Layout invariants.** FrontierRadar full-width masonry; TerminalVelocity keeps two
  Terminal-Bench boards separate with the sovereign row NOT_EVALUATED; FieldLeaders Hub rows
  never contain SZL; QuantEngine carries its SIMULATED disclosure; DecayLedger's three bands
  never blend; LivingPaper renders DIVERGES red and PARTIAL amber (never red).


Prod prerequisites

- Prod DB has the `runs` table **and the `cost_usd` column**.
- Policy env vars are optional (unset = honestly OPEN).


Publish

- Republish via the deployment flow; `A11OY_RUN_KEY` reaches prod automatically on republish.
- Post-deploy: confirm `https://a11oy.net/api/healthz` returns 200 and spot-check one wall
  endpoint returns its labeled payload.


Overview

pnpm workspace monorepo (TypeScript). Each package manages its own dependencies.

**Production**: canonical at **https://a11oy.net** (DNS Cloudflare, registrar Namecheap — DNS cutover is an EXTERNAL ACTION: add A/CNAME for a11oy.net → Replit deployment, add a11oy.net as custom domain in Replit Deployments). Former canonical **https://a-11-oy.com** and **www.a11oy.net** / **www.a-11-oy.com** 301-redirect to a11oy.net via `canonicalRedirect` middleware in `app.ts`. Also available at https://machine-innovate.replit.app (Replit autoscale). Republish checklist: `A11OY_RUN_KEY` reaches prod automatically on republish; prod DB needs the `runs` table **and the `cost_usd` column** (schema is applied — `drizzle-kit push` returned "no changes detected"); policy env vars optional (unset = honestly OPEN).

**Ownership**: product of **SZL Holdings** — branding "Alloy by SZL Holdings" (hero eyebrow, footer, page title). Visual identity is **#3af4c8** — outside inspiration (Palantir/Lumbra/etc.) is pattern-study ONLY, never repaint.

**Honesty doctrine (binding)**: every value carries a MEASURED / REPORTED / DECLARED / SIMULATED / UNKNOWN / UNAVAILABLE label; nothing is ever fabricated — failed upstreams show UNAVAILABLE, never invented numbers. Captions state exactly what each upstream's ordering/dates/totals mean. Nothing is TRAINED/EVALUATED until real signed artifacts exist AND verify in-app. Λ stays Conjecture-1, never "proven".


Stack

- pnpm workspaces · Node.js 24 · TypeScript 5.9
- Express 5 · PostgreSQL + Drizzle ORM
- Zod (`zod/v4`), `drizzle-zod` · Orval codegen (from OpenAPI spec) · esbuild (CJS bundle)


Single-page React + Vite cockpit for the multi-provider orchestration backbone. **Providers**: Sovereign GPU (own-metal default) · OpenAI · Moonshot · DeepSeek · Qwen · HF · OpenRouter · OpenRouter Free Pool (`openrouterfree`, pinned `openrouter/free`; same provisioning key, cost ZERO only when the routed model is `openrouter/free`/`:free`, else UNKNOWN) · Gemini · keyed cloud Cerebras/Groq/SambaNova (offline-until-keyed) · self-hosted local inference (Ollama/llama.cpp/vLLM/SGLang/LocalAI/HF-TGI/LM-Studio — disabled by default, SSRF-guarded loopback/private-range only, port allowlist, model-ID validated, substrate honestly UNKNOWN; ProviderFleet badges unconfigured self-hosted as `Off` not `Demo`).

**Cockpit components**: RunConsole (SSE streams, routing trail, receipt, cost line, verify chips, RoutingWaterfall), HoloCanvas, Telemetry (key-gated run ledger), ProvingGround (`/arena/run` — 2–4 pinned lanes, MEASURED speed/cost, quality NEVER scored, no auto-winner), PolicyPanel, VerticalsRadar/Orbital/Organism/EstateMesh, LayerFitCodex, MemoryPanel, HonestyAudit, ForgePanel, FlywheelPanel, ReceiptChain (in-browser Ed25519 verify).


**Full-width intelligence walls** (layout order): SovereignEstate → FrontierRadar (`/api/frontier`) → TerminalVelocity (`/api/velocity`) → FieldLeaders (`/api/leaders`) → CouncilRegistry (`/api/council`) → SzlForgeFamily (`/api/forge/family`) → QuantEngine (`/api/quant`) → ParetoFrontier → FormulaCodex|ThesisCorpus → LeanLedger (`/api/lean`) → ConjectureFactory → FormulaAnswers (`/api/formulas/answers`) → AttestationForge → OuroborosInvariants (`/api/invariants`) → LivingPaper (`/api/paper`) → DecayLedger (`/api/decay`) → SecondBrain (`/api/brain`) → IngestCodex (`/api/ingest`) → FourthWall (`/api/fourthwall`). Per-wall upstream truth + honesty stance is authoritative in `docs/data-surfaces.md`.

**Binding honesty invariants (per-wall — do not regress):** DECLARED registry walls DERIVE every posture claim from the data (`.every(...)`), never assert it in JSX — a divergent row is flagged LOUDLY, never silently mislabeled. TerminalVelocity keeps the two Terminal-Bench boards SEPARATE (never one ranking) and the sovereign row NOT_EVALUATED (tracks, never beats); its `sovereign.eval` result stays null until a real signed run lands. FieldLeaders' REPORTED Hub rows NEVER contain SZL (stance renders in a separate DECLARED band). QuantEngine math is DERIVED-over-SIMULATED (disclosed as such), no GPU speedup ever typed in. SzlForgeFamily's four bands never blend; PUBLISHED = repo-existence ONLY (never a trained/serving claim); declared weight-model rows keep a static UNTRAINED floor and are upgraded to TRAINED_RECEIPT_VERIFIED / EVAL_RECEIPT_VERIFIED ONLY at serve time by `reconcileDeclared()` from the fail-closed receipt-evidence bands (ReceiptAgent flipped 2026-07-14 on verified owner receipts; Khipu flipped 2026-07-20 when its owner-signed Hub receipts — trained 2026-07-14, published on SZLHOLDINGS/SZL-Khipu-1.5B, renamed from -BrainNavigator — were pulled back into `docs/forge/khipu/` and ed25519-verified against the committed curriculum); even the wall's footer prose derives its wording — no static "UNTRAINED" claim may sit under a verified band; the executable ReceiptAgent release contract lives as a Zod schema (`data/receiptAgentContract.ts`) where a dishonest instance is unrepresentable. DecayLedger's three bands (REPORTED thesis / DECLARED anti-decay map / MEASURED probe) never blend; agreement is never captioned as correctness. Formula corpus is 269 (never 180); locked-proven stays 8. Nothing on any wall upgrades Λ.


**Binding UI rules:** `alloy/src/lib/backbone.ts` is a HAND-MAINTAINED SSE type mirror — update in lockstep with every `/run` shape change. Visual foundation ("Signal Field"): a fixed full-viewport `-z-10` holographic atmosphere (`.holo-field` + drifting `.holo-aurora` in `index.css`) so dark regions read as DEPTH — extend the atmosphere + `.holo-rule` act-breaks for "less dark space" asks. NEVER make the shared `ui/card.tsx` base translucent/backdrop-blur (it bleeds the aurora through 30+ dense panels and is a blur-perf regression). Two-tier material: cockpit grid panels stay opaque `bg-card`; the full-width walls float as blur-free glass slabs sharing ONE material `.holo-panel-flat` (defined UNLAYERED in `index.css` so it beats Tailwind layers — same cascade as `.holo-panel`); LivingPaper keeps its own `bg-transparent border-primary/20`. Atmosphere is brand-teal ONLY — amber stays SEMANTIC (status: UNAVAILABLE/PARTIAL/pending), never sweep amber→teal.


Express backbone. **Endpoints**: `/healthz` · `/livez` (liveness — pure process) · `/readyz` (readiness — dep-aware, 503-holds-never-restart) · `/backbone/status` · `/sources` · `POST /run` · `POST /run/stream` (SSE) · `POST /trials` (key-gated) · `POST /arena/run` (key-gated Proving Ground — 2–4 pinned lanes through the full backbone, per-lane receipt+ledger row, sovereign pins only on probe evidence, no demo lanes, no auto-winner) · `/runs/recent` (key-gated) · `/grid` · `/frontier` · `/velocity` · `/leaders` · `/quant` · `/verticals` · `/organism` · `/orbital` · `/estate` · `/estate/fit` · `/backbone/mesh/probe` + `/history` · `/receipts/pubkey|recent|checkpoint` + `POST /receipts/verify` · `POST /policy/approvals` (key-gated) · `/policy` · `/flywheel/status` + `/export.jsonl` (key-gated) · `/honesty` · `/forge/models` · `/forge/family` · `/ingest` · `/lean` · `/lean/factory` · `/invariants` · `/memory` · `/formulas/answers` · `/paper` · `/decay` · `/brain` · `POST /brain/ask` (key-gated, policy-gated) · `/build-info` (signed build attestation) · `/fourthwall` (self-observation).


Subsystems (one-liners; full detail `docs/architecture-notes.md`, per-block upstream truth `docs/data-surfaces.md`):

- **Policy engine** (`lib/policy.ts`, `lib/approvals.ts`): rolling-24h spend cap over MEASURED ledger tally of ESTIMATED costs, provider allow-list filtering the whole failover chain, single-use approval tickets (ENFORCED/OPEN/MISCONFIGURED — fail-closed when misconfigured). `gateRun()` refuses BEFORE any provider call; denied ≠ ledger row.
- **Run key gate** (`lib/runKey.ts`): sha256 + timingSafeEqual on `A11OY_RUN_KEY` (Replit Secret — secrets must NEVER go in `.replit`); honestly OPEN when unset.
- **Run ledger** (`lib/runLedger.ts`): every run success AND failure → Postgres; lazy DB import so missing DATABASE_URL never crashes boot.
- **Receipts** (`lib/receipts.ts`): ed25519 over sha256 hashes (plaintext never in receipt), hash-chained; key HKDF from `SESSION_SECRET` (UNSIGNED when unset); chain RECOMPUTED per request; signed checkpoint endpoint. `canonicalJson()` here is the canonical string the owner-side Python forge signer must byte-match.
- **`/run` result**: honest `loop` (MEASURED modelMs / DERIVED overheadMs + peak-vs-sum), `cost` (ZERO/ESTIMATED/UNKNOWN, DECLARED price table × MEASURED tokens), `energy` (own-metal NVML delta, WHOLE-GPU; cloud UNKNOWN; demo ZERO), `observer` (servedNode or null, never fabricated). None of cost/energy/loop in the signed receipt canonical.
- **Backbone** (`lib/backbone.ts`, `lib/registry.ts`, `lib/rateLimit.ts`): provider router + bounded agent loop, demo fallback without creds; every model call `maxRetries: 0` + 60s timeout — the failover chain IS the retry strategy (OpenAI SDK default retries hang >70s on CF 530).
- **Providers**: OpenAI via Replit AI integration, pinned `gpt-5.5` (5.6 family unsupported on gateway — re-probe before bumping); Gemini pinned `gemini-3.5-flash`; OpenRouter = PROVISIONING key that mints an in-memory runtime key at boot (`lib/openrouterKey.ts`); `openrouterfree` shares that key/baseUrl, differs only in the pinned model (`openrouter/free`; override `OPENROUTER_FREE_MODEL`); others on `<PROVIDER>_API_KEY`.


- **Sovereign nodes** (default provider; multi-node failover tower → laptop → tower·nemo before any cloud): tower `gpu.a-11-oy.com` (keyless), laptop `gpu2.a-11-oy.com` (CF Access service token, serves `szl1:latest`), node 3 szl-nemo staged. Config `registry.ts sovereignNodes()`; `configured:false` shows `(offline)`, never faked.
- **Flywheel / Honesty / Forge**: MEASURED training-sample count (own-metal, non-demo, successful only); cache-only honesty self-report (never triggers fetches); per-node `/models` probe drives SZL-1 pipeline evidence. Owner-metal forge kits live in `docs/forge/` (SZL-1: `forge.ps1`/`rebirth.ps1`/`eval_szl.py`/`calibrate.ps1` imatrix harness; ReceiptAgent: `docs/forge/receiptagent/` + RUNBOOK; Khipu: `docs/forge/khipu/` + RUNBOOK-KHIPU, published byte-identical to github.com/szl-holdings/szl-forge `khipu/` — owner one-liner `irm https://raw.githubusercontent.com/szl-holdings/szl-forge/main/khipu/forge-khipu.ps1 | iex`) — all numbers stay UNKNOWN until the owner runs them on metal. Birth via llama.cpp GGUF + q4_K_M (never direct safetensors import — that corrupts to `@`-spam).
- **Estate drift-reconcile** (doctrine): when a live HF Space runs ahead of its repo, pull the delta BACK into the repo via PR — never let the deployed artifact diverge silently.
- **Memory organ** (`routes/memory.ts`): `GET /memory` — MEASURED work-memory window from the run ledger (episodic runs w/ receipt provenance, per-provider/node COUNT lessons, persisted requested≠served corrections, request-time selfReview — honestly NOT an overnight pass); plaintext never leaves the ledger.
- **Ingest codex** (`routes/ingest.ts` + `data/ingestRegistry.ts`): DECLARED study registry, 14 waves (full list `docs/architecture-notes.md`; wave 13 2026-07-14 frontier-retrieval: RRF paper + GraphRAG/SPLADE/RAPTOR/ColBERT/BM25S — RRF is the one adoption; SPLADE is CC BY-NC-SA, study ONLY; wave 14 2026-07-14 open-weights frontier: six HF model-card `article` studies — GLM-5.2 MIT · Kimi-K2.6 Modified-MIT · DeepSeek-V4 Pro+Flash one family entry MIT · MiniMax-M3 license:other/minimax-community verbatim · Mistral-Large-3 Apache-2.0 · Qwen3-235B-A22B Apache-2.0; licenses HF-card-verified 2026-07-14, ZERO adoptions, vendor benchmark/price numbers stay REPORTED never SZL fact). Iron rules: licenses/attribution verbatim; studied claims stay THEIR claims, never SZL fact; convergence ≠ adoption; analogies stay labeled ANALOGY. SZL runs NO git host (code lives on github.com/szl-holdings + Carlota-1/Machine-Innovate); adopting a forge is a DECLARED roadmap gap; corpus stays 269.


- **Second Brain** (`routes/brain.ts` + `lib/brainIndex.ts` + `data/brainCorpus.*` + `data/brainAskContract.ts` + `data/brainIndexEvidence.ts`): grounded RAG, two lanes that NEVER blend. In-repo lane MEASURED — a build-time-generated, committed, deterministic corpus (curated docs + 269-formula corpus + ingest takeaways) with a dependency-free BM25 index (content sha256 fingerprint; NO runtime fs read); the ONLY lane that answers. Ask display order = RRF fusion (k=60 DECLARED, Cormack 2009, wave-13) of BM25 + distinct-term coverage — floor still gates on raw BM25, graph adjacency stays pure BM25. `POST /brain/ask` (run-key + policy gated like `/run`): BM25-candidate top-k → best raw BM25 below the DECLARED retrieval floor ABSTAINS before any provider call → else grounded synthesis over ONLY the retrieved `[S#]` chunks → citation gate is FAIL-CLOSED (ANY out-of-range [S#] ⇒ ABSTAINED — a rendered dangling cite would be fabrication, never silently dropped; ANSWERED needs ≥1 valid cite AND zero out-of-range; demo can't self-cite ⇒ abstains) → gated through `BrainAskResultSchema` (dishonest instance unrepresentable) + a distinct `brain-ask` receipt (HKDF key; does NOT touch run-receipt v1 canonical). Real-Brain lane fail-closed (`brainIndexEvidence.ts`, COPY of `khipuEvidence.ts`): the owner's private graph stays UNAVAILABLE (NO_OWNER_KEY) until a signed `szl-brain-index-manifest` ed25519-verifies (5 checks; Python `canonical_json` byte-matches TS `canonicalJson`, pinned `A11OY_BRAININDEX_OWNER_KEYID`) — and even VERIFIED stays `NOT_WIRED_IN_REPO`. BM25 = lexical relevance, NEVER correctness; nothing trains/evaluates/upgrades Λ. Owner kit `docs/forge/brainindex/`.
- **Lean ledger** (`routes/lean.ts`): REPORTED CI verdicts + corpus counts verbatim, DECLARED locked-proven = 8 {F1,F4,F7,F11,F12,F18,F19,F22} (machine-enforced by no-axiom `locked_count_eight`), MEASURED local kernel check (lab runs as a temporary workflow — detached procs get reaped; fs read gated OFF in prod). No PASS upgrades Conjectures 1+2.


- **Ouroboros invariants** (`routes/invariants.ts`): 9 FALSIFIABLE runtime checks — 8 over the enumerated ledger window (hashes/row-ids only) + `factory-batch-integrity` (self-audits the committed ConjectureFactory batch: `counts.kernelAccepted` === enumerated rows; Σ byFamily === Σ byGenerator === `batchTarget`, the factory candidate count NOT the 269-corpus). Audits ARTIFACT INTEGRITY, never the mathematics. **Doctrine (binding):** true-by-construction checks are theater and EXCLUDED; runtime checks NEVER paired with Lean locked-proven; a factory accept NEVER expands locked-proven (stays 8); none upgrade Λ. Plus `latentVerification` MEASURED coverage ratio (labeled ANALOGY to JEPA — crypto digest, not a learned embedding).
- **Fourth Wall** (`routes/fourthwall.ts`): `GET /fourthwall` — the app observing itself. MEASURED process facts (direct syscalls per request) + MEASURED live route census (recursively walks the Express router stack per request — the census IS the mounted surface, no maintained list) + DECLARED identity (authored sentences labeled as authored, incl. built-by-an-AI-agent) + DECLARED crossChecks linking `/build-info` (signed attestation) and `/honesty` (self-report) — links NEVER duplicates, two sources of self-truth would diverge. NOT in the `/honesty` WINDOWS list. Final wall after IngestCodex (`FourthWall.tsx` composes cross-check chips client-side from those endpoints' own responses).
- **Sentry**: env-gated, inert without DSN (owner action pending); `@sentry/*` stays in esbuild `external`.


Design canvas sandbox.


Key Commands

- `pnpm run typecheck` — full typecheck across all packages
- `pnpm run build` — typecheck + build all packages
- `pnpm --filter @workspace/api-spec run codegen` — regenerate API hooks and Zod schemas from OpenAPI spec
- `pnpm --filter @workspace/db run push` — push DB schema changes (dev only)

See the `pnpm-workspace` skill for workspace structure and package details.


References

- `docs/data-surfaces.md` — **authoritative** block-by-block upstream reference for every REPORTED data window + receipts/flywheel/honesty + cost accounting (caches, rate limits, honesty rules).
- `docs/architecture-notes.md` — full relocated subsystem detail (component wiring, ingest waves, provider quirks, E2E verification history).
- `docs/forge/receiptagent/RUNBOOK-RECEIPTAGENT.md` — owner-metal flow to make SZL-Forge-1.5B-ReceiptAgent genuinely trained + evaluated (keygen → train → rebirth → eval → sign → commit; status DERIVED only from the signed receipts).
- `docs/forge/brainindex/RUNBOOK-BRAININDEX.md` — owner-metal flow to index the real private Brain into a signed `szl-brain-index-manifest` (keygen → index → sign → verify in-app). The real-Brain lane stays UNAVAILABLE (NO_OWNER_KEY) then NOT_WIRED_IN_REPO even once the manifest ed25519-verifies; serving is never implied by a verified index.
- `docs/OWNER-SETUP.md` — owner-side setup (GPU nodes, CF Access). `docs/tower-autostart.ps1` — owner autostart.


formal-blocks · thm:fibre-injectivity

The functor $\mathcal{F} \colon \mathcal{R}^* \to \mathrm{Hash}$ sending each receipt to its hash is injective on objects (i.e., two distinct receipts with the same output hash collide SHA-256). \text


formal-blocks · thm:thv18-07

\begin{verbatim} theorem th_v18_07_chain_length_4 : feynmanCitationChain.length = 4 \end{verbatim}


formal-blocks · 2. Definition

2. Definition — Let \(\mathbf{x} = (x_1, \dots, x_9) \in [0,1]^9\) be the runtime axis scores at a given step, and \(\mathbf{w} = (w_1, \dots, w_9)\) be a non-negative weight vector with \(\sum w_i =


formal-blocks · thm:dpo-stability

Under a DPO update~\cite{Rafailov2023} from $\pi$ to $\pi'$: \begin{equation} |\lambda_i(\pi') - \lambda_i(\pi)| \;\le\; 2 \cdot \mathrm{TV}(\pi', \pi). \end{equation} \textup{Lean:} \texttt{Lutar/DPO


formal-blocks · thm:cross-domain-sovereign

Let $\mathcal{G}_A$ and $\mathcal{G}_B$ be two sovereign-AI graft pipelines operating in disjoint deployment domains $\mathcal{D}_A$ and $\mathcal{D}_B$ (e.g.\ air-gapped cloud vs.\ tactical edge), ea


formal-blocks · thm:two-witness-soundness

\begin{equation} \mathrm{ExactlyOnePerContext}(f) \;\implies\; \mathrm{inconsistencies}(f) = 0 \;\wedge\; \mathrm{anomalyFlag}(f) = \mathrm{CLASSICAL}. \end{equation} \textup{Lean:} \texttt{Lutar/TwoW


formal-blocks · thm:graph-automorphism

For any $\Lambda$-preserving graph automorphism $\varphi$: \begin{equation} \Lambda_{\mathrm{graph}}(e) \;=\; \Lambda_{\mathrm{graph}}(\varphi \cdot e). \end{equation} \textup{Lean:} \texttt{Lutar/Gra


formal-blocks · thm:quantum-decoherence

Let $e : \mathrm{QuantumExecution}$ be a quantum-classical hybrid execution carrying a 9-axis classical score vector and a quantum register with purity $p = \mathrm{Tr}(\rho^2) \in (0, 1]$. Define the


formal-blocks · III.3a

∑_{i : Fin k} (1/k : ℝ) = 1. By Finset.sum_const + Finset.card_fin + field_simp.


formal-blocks · II.4a

If all axes ≤ 1, then Λ_k(x) ≤ 1. Closes SORRY_v16_OPEN[4] proactively. Citation: Hardy, Littlewood, and Pólya (1934), §2.10. §II.5 Schur-Concavity (V16-T6 — Honest Axiom)


formal-blocks · def:thinking-acting-gap

Let \(\pi\) be an agentic policy with two action types: \(\mathcal{A}_T\) (thinking: self-contained reasoning steps) and \(\mathcal{A}_U\) (tool use: high-variance external actions). The \emph{Thinkin


formal-blocks · theorem:(Monotone Insertion).

(Monotone Insertion). — **Theorem 3 (Window Unforgeability).** *Under the binding property of the Merkle accumulator, no PPT adversary can produce a valid closure receipt for action sequence \( a_1, \


formal-blocks · def:pac-bayes-bound

\begin{equation} \mathrm{slack}(Q,P,n,\delta) \;:=\; \sqrt{\frac{\mathrm{KL}(Q \Vert P) + \ln\!\bigl(\tfrac{2\sqrt{n}}{\delta}\bigr)}{2n}}. \end{equation} \textup{Lean:} \texttt{Lutar/PACBayes.lean},


formal-blocks · theorem:(closure).

(closure). — **Proof.** *(⇐)* If every M_{k,j} = 1, then ∏ M_{k,j} = 1 for every k, so A_k = L_k and Σ A_k = Σ L_k, hence ρ = 1.


formal-blocks · cor:governance-guarantee

For any agent output $x \in \mathcal{A}_9$ passing the Ouroboros gate ($\Lambda_9(x) \ge \tau_{\min}$), the following hold simultaneously and are jointly verifiable by \texttt{lake build Lutar}: \begi


formal-blocks · 3.1 Definition

3.1 Definition — Let `k ≥ 1` and let `x = (x₁, ..., x_k) ∈ [0,1]^k` be a vector of runtime-trust axes. The **Lutar invariant of order k** is


formal-blocks · theorem:(Leaf Collision Resistance).

(Leaf Collision Resistance). — **Theorem 2 (Monotone Insertion).** *If a log is append-only (new layers are only appended, no layer is removed or modified), then for any two snapshots at tree sizes \(


formal-blocks · IX.3f

Extends IX.3e to negative δ (ℤ arithmetic). Requires Int.add_left_cancel and List.sum over ℤ-valued lists. v16 obligation.


formal-blocks · VII.2a

Any NCHV function f satisfying ExactlyOnePerContext has zero inconsistencies under the soundness measure.


formal-blocks · IX.1b

P_moral iff all six HarmCategory flags are false. Case-split over 6 HarmCategory constructors. Zero sorry.


formal-blocks · VI.1

No non-contextual hidden-variable function exists for the Cabello 18/9 structure.


formal-blocks · thm:cursorbench-pacbayes

Let $\mathcal{H}$ be the class of agentic IDE configurations (Cursor rules $R$, subagents $A$, MCP servers $S$), and $\ell : \mathcal{H} \times \mathcal{Z} \to [0,1]$ the $\mathrm{Pass}@k$ loss. With


formal-blocks · 2.4 Closure theorem

2.4 Closure theorem — **Theorem (Λ₁₀ closure).** ρ(ℒ, M) = 1 ⇔ auditClosed(M).


formal-blocks · thm:thv18-12

\begin{verbatim} theorem th_v18_12a_product_rearrange (a b c d : Nat) : (a * b) * (c * d) = (a * c) * (b * d) theorem th_v18_12b_two_axis_product (x0 x1 y0 y1 : Nat) : (x0 * y0) * (x1 * y1) = (x0 * x1


formal-blocks · thm:wheeler-coherence

Every receipt $r \in \mathcal{R}^*$ satisfies $\Lambda(r) \ge \tau_{\min}$ (the Doctrine~v6 gate threshold). \textup{Doctrine:} v17 Wheeler closure (DOI~\cite{LutarThesisV17}). \textup{Invariant:} \te


formal-blocks · thm:pac-bayes-main

With probability at least $1 - \delta$ over $S \sim D^n$: \begin{equation} R(Q) \;\le\; \hat{R}_S(Q) + \mathrm{slack}(Q,P,n,\delta). \end{equation} \textup{Lean:} \texttt{Lutar/PACBayes.lean}, \texttt


formal-blocks · thm:coe-axis-map

The CoE claim taxonomy maps bijectively onto $\Lambda$-axes: \begin{align*} \mathrm{citation} &\mapsto \lambda_6\,(\text{evidence}),\\ \mathrm{numerical} &\mapsto \lambda_6\,(\text{evidence}) \wedge \


formal-blocks · 3.3 Theorem 1 (Uniqueness)

3.3 Theorem 1 (Uniqueness) — > **Theorem 1.** Let `Λ, Λ' : [0,1]^k → [0,1]` both satisfy A1–A4. Then `Λ = Λ'`.


formal-blocks · thm:lambda-lower

For every $k > 0$ and $x \in \mathcal{A}_k$: \begin{equation} \min_{i \in [k]} x_i \;\le\; \Lambda_k(x). \end{equation} \textup{Lean:} \texttt{Lutar/Bound.lean}, \texttt{min\_le\_\(\Lambda\)}, line~73


formal-blocks · III.3

For k ≥ 1 and c : ℝ≥0:


formal-blocks · def:sparse-attn

Following rasbt/LLMs-from-scratch DSA~\cite{rasbtDSA} (Apache-2.0, SHA~\texttt{63224d6e}): a $k$-sparse attention pattern $\alpha^{(k)}$ satisfies $|\{i : \alpha^{(k)}_i > 0\}| \le k$, $\sum_i \alpha^


formal-blocks · VII.2d

No NCHV function exists for the Cabello 18/9 structure.


formal-blocks · thm:lambda-upper

For every $k > 0$ and $x \in \mathcal{A}_k$: \begin{equation} \Lambda_k(x) \;\le\; \max_{i \in [k]} x_i. \end{equation} \textup{Lean:} \texttt{Lutar/Bound.lean}, \texttt{Lambda\_le\_max}, line~31. \te


formal-blocks · thm:thv18-03

\begin{verbatim} theorem th_v18_03_kraft_equality : (Finset.univ : Finset DoctrineLabel).sum (fun l => (1 : Real) / 2 ^ codewordLen l) = 1 \end{verbatim}


formal-blocks · thm:dual-witness-soundness

Under the collision-resistance assumption (axiom A15), an adversary cannot forge a \texttt{APPROVE} verdict for an action \(a\) with \(\Lambda(a) < \lambda_{\mathrm{crit}}\) without breaking SHA-256.


formal-blocks · thm:zero-kl

$\mathrm{KL}(\pi' \Vert \pi) = 0 \implies \Lambda_9(\pi') = \Lambda_9(\pi)$. \textup{Lean:} \texttt{Lutar/DPOFeasibility.lean}, \texttt{pinsker\_coords\_eq\_of\_kl\_zero}. \textup{Status:} kernel-veri


formal-blocks · IX.2

For integers a, b, c, d:


formal-blocks · thm:openmdw-provenance

Let $\mathcal{L}$ be the OpenMDW model-license DAG and $\mathcal{D}$ the HuggingFace dataset-lineage DAG. The merged DAG $(\mathcal{L} \cup \mathcal{D}, \leq_P)$ has a linear extension in which every


formal-blocks · thm:thv18-08

\begin{verbatim} theorem th_v18_08_pendant_value_is_sum (r : OrganReceipt) : pendantValue r = (r.decisions.map decisionValue).sum theorem th_v18_08b_root_value_is_sum (r : KhipuRootReceipt) : rootValu


formal-blocks · thm:sparse-attn-bound

\begin{equation} |\Lambda(\alpha) - \Lambda(\alpha^{(k)})| \;\le\; 2 \cdot \varepsilon(k, n). \end{equation} \textup{Lean (skeleton):} \texttt{thesis\_v18/lean\_skeletons/CursorBenchPACBayes.lean} (cl


formal-blocks · III.4c

The uniform weight vector (1/k, …, 1/k) on k axes sums to 1 — it is a probability vector. This connects A3 to the information-theoretic principle: the uniform distribution is the maximum-entropy prior


formal-blocks · R3, receipt-chain associativity

$\Lambda$-invariance is closed under composition of rewrites.


formal-blocks · cor:hoeffding

\begin{equation} \Pr_{S \sim D^n}\!\bigl[\,R(Q) - \hat{R}_S(Q) \ge \varepsilon\,\bigr] \;\le\; e^{-2n\varepsilon^2}. \end{equation} \textup{Lean:} \texttt{Lutar/PACBayes.lean}, \texttt{hoeffding\_mgf\


formal-blocks · 2.2 RefVectors.lean — Runtime Parity The

2.2 RefVectors.lean — Runtime Parity Theorem — `RefVectors.lean` [INTERNAL: RefVectors.lean, SHA 0f8189cc21d5d436d9bd3726075212dfe857abee, github.com/szl-holdings/lutar-lean] is a Lean 4 module that o


formal-blocks · IX.1

The sum of the six Horus-Eye fractions equals 63/64:


formal-blocks · def:governance-drift

A session exhibits \emph{governance drift} if the linear regression coefficient of $\Lambda_k$ over $k$ is negative: \[ \hat{\beta} = \frac{\sum_{k=1}^{n}(k - \bar{k})(\Lambda_k - \bar{\Lambda})} {\su


formal-blocks · thm:quantum-lambda

For density matrix $\rho$ and unitary $U$: \begin{align} \Lambda_{\mathrm{quantum}}(\rho) &\;\le\; 1, \\ \Lambda_{\mathrm{quantum}}(U\rho U^\dagger) &\;=\; \Lambda_{\mathrm{quantum}}(\rho). \end{align


formal-blocks · thm:receipt-chain-cardinality

Let $C = (r_0, r_1, \dots, r_{n-1})$ be a chain of $n$ receipts, each anchored by $h_j = \mathrm{SHA256}(r_j \,\|\, h_{j-1})$. In the random-oracle model, \[ \Pr[\text{no collision in } C] \;\geq\; 1


formal-blocks · IX.6

The nine governance axis denominators divide 60⁸. This establishes that the nine-axis weight scheme is regular in the Babylonian sexagesimal number system — a bridge between the ancient base-60 tradit


formal-blocks · X.3

The Catoni (2007) PAC-Bayes bound (1/(1 − λ/2)) · (r + kl/(λn)) is monotone in KL. Proof: mul_le_mul_of_nonneg_left + add_le_add_left + div_le_div_right. Citation: Catoni (2007), IMS Monograph Series


formal-blocks · thm:graph-lambda-le-one

For any \texttt{GraphExecution} $e$: \begin{equation} \Lambda_{\mathrm{graph}}(e) \;:=\; \Bigl(\prod_{v \in V(e)} \Lambda_9(\mathrm{scores}(v))\Bigr)^{1/|V(e)|} \;\le\; 1. \end{equation} \textup{Lean:


formal-blocks · R1, single-axis repack

For any single-axis rewrite $r$ that acts as the identity on coordinate $i$, $\Lambda(r(x)) = \Lambda(x)$ for all $x$.


formal-blocks · def:gateLID

The \emph{\(\Lambda\)GateLID} for threshold $\tau$ is $\{\pi \mid \forall i,\, \pi(i) \ge \tau\}$. The DPO Lipschitz constant is $L_\Lambda = 2$ (\texttt{Lutar/DPOFeasibility.lean}, \texttt{def gateLi


formal-blocks · thm:lean-soundness

The Lean~4 kernel is sound with respect to the Calculus of Constructions extended with Quotient Types and Propositional Extensionality~\cite{MouraKN2021}. Any theorem passing \texttt{lake build Lutar}


formal-blocks · def:nchv

The Cabello--Estebaranz--Garc\'ia-Alcaine (CEGA) structure~\cite{Cabello1996} consists of 18 vectors in $\mathbb{R}^4$ forming 9 orthogonal bases (contexts). An NCHV assignment $f \colon \mathrm{Fin}\


formal-blocks · 2.1 Definition

2.1 Definition — Fix a finite ordered set of *layers* L = {L₁, …, L_n}; in the runtime under study, these are the published versions of the Lutar family that have shipped routes, so n = 7 with layers


formal-blocks · def:receipt-impl

A \emph{receipt} is a tuple \(r = (\mathrm{id}, t, s_{\mathrm{in}}, s_{\mathrm{out}}, \Lambda, w_1, w_2, h_{\mathrm{prev}})\) where: \begin{itemize} \item \(\mathrm{id}\) is a UUID4 receipt identifier


formal-blocks · thm:exit0

Given \(\Pi_{\mathrm{green}}\) holds, the process \texttt{python3 OUROBOROS\_RUN\_ALL.py} exits with code~0. Conversely, if any module \(m_i\) raises an uncaught exception or asserts \texttt{False}, t


formal-blocks · (pre-formal)

v1 'The Loop Is the Product' — narrative paper, no formal theorem environments; introduces bounded recursion as audit primitive.


formal-blocks · def:path-integral

For execution path $\gamma = (S_0 \to S_1 \to \cdots \to S_T)$: \begin{align} \mathcal{S}[\gamma] &\;:=\; \sum_{t=1}^{T} \bigl[-\ln \Lambda(r_t) + \beta \cdot \mathrm{cost}(r_t)\bigr], \\ Z_{\mathrm{a


formal-blocks · thm:coe-chain-integrity

A CoE claim chain $\mathcal{C} = (c_1, \ldots, c_m)$ forms a morphism sequence in the receipt category $\mathcal{R}$ (Definition~\ref{def:receipt-category}). Its hash-chain integrity follows from Theo


formal-blocks · VII.2c

For any NCHV function f:


formal-blocks · thm:lambda-mp-inv

For any permutation $\sigma$ of $\mathcal{N}(v)$: $\Lambda^{(v)}_{\ell+1}(\sigma \cdot x) = \Lambda^{(v)}_{\ell+1}(x)$. \textup{Lean:} follows from Theorem~\ref{thm:graph-automorphism} by restricting


formal-blocks · theorem:(Window Unforgeability).

(Window Unforgeability). — ---


formal-blocks · thm:doi-integrity

A module \(m_i\) may claim a DOI \(d\) in its header only if: \begin{enumerate} \item \(d\) is listed in \texttt{\_MODULE\_DOIS}, \emph{and} \item an HTTP GET to \texttt{https://doi.org/}\(d\) returns


formal-blocks · thm:thv18-06

\begin{verbatim} theorem th_v18_06_brahmi_distinction : Option.some (0 : Int) <> Option.none \end{verbatim}


formal-blocks · IX.4

The Liu Hui sequence is monotone increasing and bounded above by π. Sorry deferred to Mathlib monotone convergence API naming uncertainty. Mathematical truth: TRUE (alternating-series / monotone-conve


formal-blocks · thm:doctrine-compositionality

The Doctrine~v6 predicate $\mathcal{D}_6(M)$ is closed under module union: \[ \bigwedge_{j=1}^{n} \mathcal{D}_6(M_j) \;\implies\; \mathcal{D}_6\!\Bigl(\bigcup_{j=1}^{n} M_j\Bigr). \]


formal-blocks · XIII.2

HUKLLA ∧ OVERWATCH ∧ DPI → governanceAllow.


formal-blocks · VII.2b

Every vector v ∈ Fin 18 appears in exactly 2 of the 9 Cabello contexts. Proved by decide over the explicit finite list.


formal-blocks · IX.3

The Babylonian iteration T(x) = (x + 2/x)/2 is a Banach contraction on the interval [1, 2]:


formal-blocks · II.1

Λ k x = (Finset.univ.prod x) ^ (1/k) for k > 0. Proof: simp [Λ, hk.ne']. Operational counterpart: ouroboros/runtime/lambda-gate/src/gate.ts.


formal-blocks · thm:coe-soundness

If all four CoE checks pass for every claim $c_i$ in chain $\mathcal{C}$, then $\mathcal{C}$ is CoE-sound: all numerical claims are within tolerance (I1); no specification violations (I2); all referen


formal-blocks · thm:pac-bayes-mono

For $\mathrm{KL}_1 \le \mathrm{KL}_2$: \begin{equation} \mathrm{pacBayesBound}(\hat{R}, \mathrm{KL}_1, n, \delta) \;\le\; \mathrm{pacBayesBound}(\hat{R}, \mathrm{KL}_2, n, \delta). \end{equation} \tex


formal-blocks · thm:thv18-16

\begin{verbatim} theorem th_v18_16a_all_citations_nonempty : forall step in feynmanLineage, step.citation <> "" theorem th_v18_16b_chain_has_four_steps : feynmanLineage.length = 4 \end{verbatim}


formal-blocks · def:green-gate

A module \(m_i \in \mathcal{M}\) satisfies the GREEN gate if and only if \texttt{main()} returns without raising any exception and the process \texttt{sys.exit} code contributed by \(m_i\) is zero.


formal-blocks · R2, independent commute

Let $r_1, r_2$ act on disjoint axis subsets. If each is $\Lambda$-invariant, then so is $r_1 \circ r_2$.


formal-blocks · XI.2

For any δ : ℤ, δ =≠ 0: checksum(tamper(r, i, δ)) =≠ checksum(r). Proof route: extend pendant value to ℤ; checksumZ r’ = checksumZ r + δ; δ =≠ 0 → inequality. Requires List.sum_set or manual induction


formal-blocks · def:lambda

For $k \geq 1$ and an axis vector $x \in [0,1]^k$, the Lutar invariant is: \[ \Lambda(x) \;=\; \left(\prod_{i=1}^{k} x_i\right)^{1/k} \] with Egyptian unit-fraction weights $w_i = 1/k$ for all $i$. In


formal-blocks · 1

2^{-l_i}\) kraft_inequality_doctrine


formal-blocks · def:receipt

A \emph{governance receipt} \(\rho\) is a tuple \(\rho = (\tau, \lambda, \mathbf{a}, \mathbf{w}, \sigma)\) where: \begin{itemize} \item \(\tau\) is a monotone timestamp (Unix epoch, millisecond precis


formal-blocks · A1

Monotonicity — > For every \(i \in \{1, \dots, 9\}\) and every \(\mathbf{x} \in [0,1]^9\), if \(x_i' \geq x_i\) then \(\Lambda(\mathbf{x}'; \mathbf{w}) \geq \Lambda(\mathbf{x}; \mathbf{w})\), where \(


formal-blocks · III.4b

If k × (1/ n) = 1 then n = k. Proof: exact_mod_cast. Lean file: Lutar/Egyptian.lean, main branch.


formal-blocks · thm:quantum-chain-bound

Let $e_1, e_2, \dots, e_n$ be quantum-classical executions sharing a common quantum register, where execution $e_j$ applies a CPTP map $\mathcal{N}_j$ to the register state. The composed execution $e_


formal-blocks · thm:topk-isomorphism

Under permutation-invariant aggregation, the three top-$k$ operators -- $\Lambda$-MP (Def.~\ref{def:lambda-mp}), DSA (Def.~\ref{def:sparse-attn}), and TurboVec (Def.~\ref{def:turbovec}) -- are $\Lambd


formal-blocks · IX.3d

A khipu with one pendant has root value equal to that pendant. Zero sorry.


formal-blocks · thm:thv18-02

\begin{verbatim} theorem th_v18_02_doctrine_alphabet_size_4 : Fintype.card DoctrineLabel = 4 \end{verbatim}


formal-blocks · thm:thv18-14

\begin{verbatim} axiom sha256_collision_resistant : forall (b1 b2 : ReceiptBlob), sha256 b1 = sha256 b2 -> b1 = b2 \end{verbatim}


formal-blocks · thm:precision-bound

For two independent witnesses with empirical risks $\hat{R}_1, \hat{R}_2$ over $m$ i.i.d.\ samples: \begin{equation} \Pr\bigl[|\hat{R}_1 - \hat{R}_2| > \varepsilon\bigr] \;\le\; 2\exp\!\bigl(-2m\varep


formal-blocks · X.2

The Catoni (2007) PAC-Bayes bound (1/(1 − λ/2)) · (r + kl/(λn)) is monotone in KL. Proof: mul_le_mul_of_nonneg_left + add_le_add_left + div_le_div_right. Citation: Catoni (2007), DOI:10.1214/074921707


formal-blocks · def:audit-fibre

For target hash $h^*$, the \emph{audit fibre} is $\mathcal{F}(h^*) = \{r \in \mathcal{R}^* \mid h_r = h^*\}$. By A15, $|\mathcal{F}(h^*)| \le 1$ except with negligible probability.


formal-blocks · IX.3e

If any pendant is modified by δ > 0, the checksum changes:


formal-blocks · def:coe-claim

Following ScientistOne~\cite{Meng2026} (arXiv:2605.26340): a CoE claim is $\mathrm{claim} = (\mathrm{typ}, \mathrm{content}, \mathrm{evidence}, \Lambda_{\mathrm{claim}})$ with $\mathrm{typ} \in \{\mat


formal-blocks · thm:universal-composability

Let $\mathcal{S}$ be any software system that (a)~exposes a Python or TypeScript callable boundary, and (b)~produces output events that can be represented as (input-hash, output-hash) pairs. Then the


formal-blocks · thm:openmdw-grant

Let $\mathrm{Grant}(r)$ denote the OpenMDW-1.1 grant scope (copyright, patent, database, trade-secret, royalty-free flags) associated with provenance record $r$. Let $r_1 \leq_P r_2$ in the total prov


formal-blocks · def:soft-gate

A module action with \(\Lambda < \lambda_{\min}\) is flagged in the receipt as \texttt{WARN}; the action is \emph{allowed} but the flag is propagated to the Doctrine~v6 scanner.


formal-blocks · thm:schur-concave

For $x \prec y$ in the majorisation order~\cite{HLP1934}: \begin{equation} x \prec y \;\implies\; \Lambda_k(x) \;\le\; \Lambda_k(y). \end{equation} \textup{Lean:} \texttt{Lutar/Lambda/SchurConcave.lea


formal-blocks · thm:thv18-01

\begin{verbatim} theorem th_v18_06_terminates (s0 : AgentState) : exists n : Nat, n <= turnBudget s0 + 1 /\ Nat.iterate agentStep n s0 = .Done \end{verbatim}


formal-blocks · thm:unique-aggregator

Under axioms \textup{A1--A4}, the unique aggregator is the \emph{geometric mean}: \begin{equation} \Lambda_k(x) \;=\; \Bigl(\prod_{i=1}^{k} x_i\Bigr)^{1/k}. \end{equation} \textup{Lean module:} \textt


formal-blocks · thm:path-integral

$Z_{\mathrm{audit}}$ is finite and monotone-decreasing: \[ Z_{\mathrm{audit}}^{(t+1)} \;\le\; Z_{\mathrm{audit}}^{(t)} \] whenever every step-$(t+1)$ receipt has $\Lambda > 0$. \textup{Lean:} \texttt{


formal-blocks · thm:cursor-bench-bound

For an agentic evaluator executing $T$ tool calls per episode, each $\Lambda$-gated: \begin{equation} R_{\mathrm{episode}}(Q) \;\le\; \hat{R}_{\mathrm{episode}}(Q) + T \cdot \mathrm{slack}(Q, P, n/T,


formal-blocks · thm:materialx-lambda

Let $G = (N, E, \ell)$ be a MaterialX node graph with \texttt{lambda\_receipt} attributes. Suppose the \emph{receipt-flow invariant} holds: $\hat{\Lambda}(\ell(v))_i \leq \hat{\Lambda}(\ell(u))_i$ for


formal-blocks · VII.2e

No agent response can have zero inconsistencies under the Cabello structure: ∀ f : NCHV, ¬ ExactlyOnePerContext f.


formal-blocks · IX.3a

pendantValue_def unfolds the pendant value formula. Lean file: Lutar/ Khipu/SummationInvariant.lean, main branch.


formal-blocks · def:epistemic-floor

Only kernel-verified theorems achieve $\lambda_6 = 1.0$. LLM-generated claims are capped at $\tau_{\mathrm{LLM}} = 0.75$. Unverified conjectures are capped at $\tau_{\mathrm{conj}} = 0.50$. \textup{Do


formal-blocks · thm:wos-pi-equiv

Let $D \subset \mathbb{R}^d$ be a bounded domain, $\phi : D \to \mathbb{R}_{\geq 0}$ an audit functional, $\mu$ the absorbed Wiener measure. Define the v15 \emph{path-integral audit sum} $\mathcal{A}_


formal-blocks · thm:thv18-10

\begin{verbatim} theorem th_v18_10_append_increases_sum (l : List Nat) (delta : Nat) (hdelta : 0 < delta) : l.sum < (l ++ [delta]).sum theorem th_v18_10b_sum_append (l1 l2 : List Nat) : (l1 ++ l2).sum


formal-blocks · thm:wos-reuse

The Walk-on-Spheres estimator~\cite{dEon2023} for $\Lambda$-boundary conditions on domain $\Omega$ satisfies: \begin{enumerate} \item \textbf{Unbiasedness}: $\mathbb{E}[\hat{u}(x_0)] = u(x_0)$ for all


formal-blocks · II.3

For k ≥ 1 and x ≤ y pointwise: Λ_k(x) ≤ Λ_k(y).


formal-blocks · II.5

Λ_k is Schur-concave on (ℝ≥0)^k: if y majorizes x, then Λ_k(y) ≥ Λ_k(x). Honest axiom; Mathlib4 majorization API incomplete as of v4.13.0. Proof route: Marshall-Olkin- Arnold 2011,


formal-blocks · thm:axpo-coe

Let $\mathcal{M}$ be an AXPO-trained agent and $\mathcal{C} = (C_1, C_2, C_3, C_4)$ a ScientistOne Chain-of-Evidence with four audit layers. If all four audits pass, then $\mathcal{M}$'s output passes


formal-blocks · thm:graph-pac-bayes

Let $e$ be a \texttt{GraphExecution} with $|V|$ vertices. With probability $\ge 1 - \delta$: \begin{equation} R_{\mathrm{graph}}(Q) \;\le\; \hat{R}_{\mathrm{graph}}(Q) + |V| \cdot \mathrm{slack}(Q, P,


formal-blocks · def:turbovec

Following Zandieh, Daliri et al.~\cite{Zandieh2025} (TurboVec/TurboQuant): \begin{equation} \tilde{\alpha}^{(k)} \;=\; \mathrm{TopK}_{k}\!\bigl(\mathrm{softmax}(Q\tilde{K}^T/\sqrt{d})\bigr), \quad \|\


formal-blocks · cor:psi2

At $t = \sqrt{2n}$, the excess satisfies: \begin{equation} \mathbb{E}\!\bigl[e^{\sqrt{2n}\,\cdot\,\mathrm{excess}}\bigr] \;\le\; e^{1/4}, \end{equation} establishing $\|\mathrm{excess}\|_{\psi_2} \le


formal-blocks · thm:axpo-gain

Under AXPO with subgroup resampling, the average Pass@1 improves by $+1.8\,\mathrm{pp}$ over SFT+GRPO at the 8B parameter scale on nine multimodal benchmarks. Furthermore, SFT+AXPO at 8B surpasses the


formal-blocks · thm:lambda-bounded

For all axis vectors \((\lambda_1, \ldots, \lambda_9) \in [0,1]^9\), \[ 0 \;\leq\; \Lambda \;\leq\; 1. \] Equality \(\Lambda = 1\) holds if and only if \(\lambda_j = 1\) for all \(j\). Equality \(\Lam


formal-blocks · A4

Page-curve concavity — > \(\Lambda\) is concave on the positive orthant \((0,1]^9\). Equivalently, for any two points \(\mathbf{a}, \mathbf{b} \in (0,1]^9\) and any \(t \in [0,1]\),


formal-blocks · def:lambda-vector

The \emph{$\Lambda$-axis governance vector} is \begin{equation} \Lambda \;=\; (\lambda_1,\ldots,\lambda_9) \;\in\; [0,1]^9, \end{equation} with axes: (1)~data, (2)~model, (3)~compute, (4)~behavior, (5


formal-blocks · thm:wos-convergence

Let $\hat{\mathcal{A}}^{(m)}_\mathrm{WoS}(x)$ denote the Monte Carlo estimator of $\mathcal{A}_\mathrm{WoS}(x)$ using $m$ independent WoS paths. Under the assumption that $\phi$ is $L$-Lipschitz on $D


formal-blocks · def:receipt-category

The \emph{receipt chain category} $\mathcal{R}$ has: \begin{itemize} \item \textbf{Objects}: SHA-256-addressed agent states $S_0, S_1, \ldots$; \item \textbf{Morphisms}: receipts $r = (h_{\mathrm{prev


formal-blocks · II.4

For k ≥ 1:


formal-blocks · def:lutar-axioms

An aggregator $\Phi \colon (\mathrm{Fin}\,k \to \mathbb{R}_{\ge 0}) \to \mathbb{R}_{\ge 0}$ satisfies the \emph{Lutar axioms} when: \begin{align} \text{A1 (Monotonicity):}&\quad \forall\,x,y,\; (\fora


formal-blocks · thm:sovereign-lambda

Let $\mathcal{G} := \mathcal{G}_\mathrm{TurboVec} \circ \mathcal{G}_\mathrm{IQT} \circ \mathcal{G}_\mathrm{UDS\text{-}AirGap}$. \begin{enumerate} \item For axes $i \in \{3, 6, 7\}$ (Governance, Sovere


formal-blocks · thm:nist-oper-completeness

Let $F : \mathbf{RMF} \to \mathbf{\Lambda}$ be the functor from Theorem~\ref{thm:nist-rmf-functor}. For any SZL substrate module $M$ that passes Doctrine~v6 (i.e.\ $\mathcal{D}_6(M)$ holds), let $\Lam


formal-blocks · def:hard-gate

A module action with \(\Lambda < \lambda_{\mathrm{crit}}\) is \emph{blocked}: the runner sets \texttt{G(m\_i) = 1} and the process exits~1.


formal-blocks · def:dual-witness

Property $P$ has a \emph{dual witness} iff \begin{equation} \mathrm{DualWitness}(P) \;\iff\; \exists\, W_1 \ne W_2 \in \mathcal{W},\; W_1 \vDash P \;\wedge\; W_2 \vDash P, \end{equation} where $\mathc


formal-blocks · thm:rmf-completeness

For any AI system $S$ instrumented with the SZL $\Lambda$-axis substrate, all four NIST AI RMF functions are operationally satisfied: GOVERN via Doctrine~v6 and the axiom ceiling; MAP via per-action 9


formal-blocks · conj:lambda-uniqueness

Let $\Lambda : [0,1]^k \to [0,1]$ satisfy A1 (monotonicity), A2 (positive homogeneity of degree 1), A3 (Egyptian-exact diagonal normalization), and A4 (bounded by max axis). Then \[ \Lambda(x) \;=\; \


formal-blocks · thm:schur

The two-axis \(\Lambda\)-score is Schur-concave: for all \(\mathbf{s}, \mathbf{t} \in [0,1]^2\) with \(\mathbf{s}\) majorised by \(\mathbf{t}\), \[ \Lambda_k(\mathbf{s}) \;\geq\; \Lambda_k(\mathbf{t})


formal-blocks · thm:axiom-reduction

The reduction from 24 axioms (v14) to 11 (v16) -- a 54\% decrease -- is, to the best of our search at the time of writing (2026-05-28; search scope: Lean~4 / Mathlib4 repository, Lean Together 2025 pr


formal-blocks · IX.5

Theorem Status madhavaRemainderBound_nonneg PROVED zero-sorry madhavaRemainderBound_at_zero PROVED zero-sorry madhavaRemainderBound_anti PROVED zero-sorry (linarith) SORRY-TAGGED (~16h; Mathlib madhav


formal-blocks · thm:lambda-composition

Let $f$ and $g$ be composable substrate grafts with $\hat{\Lambda}(f), \hat{\Lambda}(g) : \mathrm{Fin}\,9 \to \mathbb{R}_{\geq 0}$. For every axis $i \in \{0,\dots,8\}$, \[ \hat{\Lambda}(g \circ f)_i


formal-blocks · thm:thv18-15

\begin{verbatim} /-- A bounded agent terminates within its fuel budget. -/ theorem th_v18_15a_bounded_agent_terminates (a : Agent) (n : Nat) (h_bounded : IsBoundedAgent a n) : AgentTerminates a n \end


formal-blocks · 4.5 Underlying axiom-suite evidence

4.5 Underlying axiom-suite evidence — The audit operator depends on the soundness of the Λ invariant (v1 through v9) it audits. At commit `6c5c28366`, the consolidated test surface reports:


formal-blocks · 4.2 Theorem 2 (Tamper-evidence)

4.2 Theorem 2 (Tamper-evidence) — > **Theorem 2.** Forging an undetected modification of receipt `R_i` for `i < n` requires producing a SHA-256 second-preimage. The receipt-chain attack model reduces


formal-blocks · A2

Zero-pinning — > If there exists \(i\) with \(x_i = 0\) and \(w_i > 0\), then \(\Lambda(\mathbf{x}; \mathbf{w}) = 0\). Conversely, if \(x_i = 0\) but \(w_i = 0\), then axis \(i\) is degenerate and doe


formal-blocks · (no formal blocks)

v9: no explicit theorem/axiom blocks detected; prose/empirical paper.


formal-blocks · thm:thv18-09

\begin{verbatim} theorem th_v18_09a_product_comm (a b : Nat) : a * b = b * a theorem th_v18_09b_two_axis_gm_symmetric (a b : Nat) : geometricMeanTwoAxis a b = geometricMeanTwoAxis b a \end{verbatim}


formal-blocks · 2.2 Closure theorem

2.2 Closure theorem — **Theorem (closure).** *Assume L_k > 0 for every k. Then ρ = 1 if and only if M_{k,j} = 1 for every (k, j).*


formal-blocks · IX.3c

Empty khipu has root value 0. Zero sorry.


formal-blocks · thm:thv18-05

\begin{verbatim} theorem th_v18_05_receipt_transduction_invariant (r : Receipt) (h : Codec.decode (Codec.encode r) = some r) : (Codec.decode (Codec.encode r)).map Receipt.contentId = some r.contentId


formal-blocks · IX.3b

The root value equals the sum of pendant values. Zero sorry.


formal-blocks · thm:lambda-bound

For all \(k \geq 0\) and all \(\mathbf{s} \in [0,1]^n\): \[ \min_i s_i \;\leq\; \Lambda_k(\mathbf{s}) \;\leq\; \max_i s_i. \]